From 128548a5c064b8f817c2fc4988b3da383731e65e Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Tue, 19 Sep 2006 10:38:31 +0000 Subject: [PATCH] Disabled autoconversion of hash keys (from string to unicode) for PHP arrays --- Zend/zend_API.c | 507 +------------- Zend/zend_API.h | 1047 ++++++++++++++++++++++------- Zend/zend_builtin_functions.c | 36 +- Zend/zend_compile.c | 2 +- Zend/zend_exceptions.c | 28 +- Zend/zend_execute_API.c | 2 +- Zend/zend_hash.c | 231 ++++++- Zend/zend_hash.h | 26 + Zend/zend_operators.c | 6 +- Zend/zend_vm_def.h | 6 +- Zend/zend_vm_execute.h | 90 +-- Zend/zend_vm_execute.skl | 2 +- ext/date/php_date.c | 152 ++--- ext/dom/node.c | 4 +- ext/filter/logical_filters.c | 4 +- ext/session/session.c | 34 +- ext/simplexml/simplexml.c | 20 +- ext/soap/php_encoding.c | 2 +- ext/soap/php_packet_soap.c | 33 +- ext/soap/soap.c | 78 +-- ext/sqlite/sqlite.c | 6 +- ext/standard/basic_functions.c | 30 +- ext/standard/datetime.c | 18 +- ext/standard/dns.c | 84 +-- ext/standard/file.c | 26 +- ext/standard/filestat.c | 26 +- ext/standard/http_fopen_wrapper.c | 2 +- ext/standard/image.c | 10 +- ext/standard/info.c | 8 +- ext/standard/iptc.c | 4 +- ext/standard/microtime.c | 10 +- ext/standard/proc_open.c | 18 +- ext/standard/scanf.c | 6 +- ext/standard/streamsfuncs.c | 42 +- ext/standard/string.c | 90 +-- ext/standard/url.c | 16 +- ext/zlib/zlib.c | 2 +- main/main.c | 6 +- main/output.c | 28 +- main/php_variables.c | 32 +- main/streams/filter.c | 4 +- main/streams/memory.c | 8 +- main/streams/streams.c | 16 +- main/streams/unicode_filter.c | 4 +- main/streams/userspace.c | 2 +- main/streams/xp_socket.c | 6 +- 46 files changed, 1576 insertions(+), 1238 deletions(-) diff --git a/Zend/zend_API.c b/Zend/zend_API.c index f3a3e8d150..923cad4960 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -1150,11 +1150,9 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC, ZEND_API int _array_init(zval *arg ZEND_FILE_LINE_DC) { - TSRMLS_FETCH(); - ALLOC_HASHTABLE_REL(Z_ARRVAL_P(arg)); - zend_u_hash_init(Z_ARRVAL_P(arg), 0, NULL, ZVAL_PTR_DTOR, 0, UG(unicode)); + zend_u_hash_init(Z_ARRVAL_P(arg), 0, NULL, ZVAL_PTR_DTOR, 0, 0); Z_TYPE_P(arg) = IS_ARRAY; return SUCCESS; } @@ -1320,520 +1318,31 @@ ZEND_API int add_assoc_function(zval *arg, char *key, void (*function_ptr)(INTER } -ZEND_API int add_assoc_long_ex(zval *arg, char *key, uint key_len, long n) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_LONG(tmp, n); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_u_assoc_long_ex(zval *arg, zend_uchar type, zstr key, uint key_len, long n) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_LONG(tmp, n); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_assoc_null_ex(zval *arg, char *key, uint key_len) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_NULL(tmp); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_u_assoc_null_ex(zval *arg, zend_uchar type, zstr key, uint key_len) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_NULL(tmp); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_assoc_bool_ex(zval *arg, char *key, uint key_len, int b) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_BOOL(tmp, b); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_u_assoc_bool_ex(zval *arg, zend_uchar type, zstr key, uint key_len, int b) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_BOOL(tmp, b); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_assoc_resource_ex(zval *arg, char *key, uint key_len, int r) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_RESOURCE(tmp, r); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_u_assoc_resource_ex(zval *arg, zend_uchar type, zstr key, uint key_len, int r) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_RESOURCE(tmp, r); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_assoc_double_ex(zval *arg, char *key, uint key_len, double d) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_DOUBLE(tmp, d); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_u_assoc_double_ex(zval *arg, zend_uchar type, zstr key, uint key_len, double d) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_DOUBLE(tmp, d); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRING(tmp, str, duplicate); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_u_assoc_string_ex(zval *arg, zend_uchar type, zstr key, uint key_len, char *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRING(tmp, str, duplicate); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRINGL(tmp, str, length, duplicate); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_u_assoc_stringl_ex(zval *arg, zend_uchar type, zstr key, uint key_len, char *str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRINGL(tmp, str, length, duplicate); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_assoc_unicode_ex(zval *arg, char *key, uint key_len, UChar *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODE(tmp, str, duplicate); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_u_assoc_unicode_ex(zval *arg, zend_uchar type, zstr key, uint key_len, UChar *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODE(tmp, str, duplicate); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_assoc_unicodel_ex(zval *arg, char *key, uint key_len, UChar *str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODEL(tmp, str, length, duplicate); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_u_assoc_unicodel_ex(zval *arg, zend_uchar type, zstr key, uint key_len, UChar *str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODEL(tmp, str, length, duplicate); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_assoc_zstr_ex(zval *arg, char *key, uint key_len, zend_uchar type, zstr str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_ZSTR(tmp, str, type, duplicate); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_assoc_zstrl_ex(zval *arg, char *key, uint key_len, zend_uchar type, zstr str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_ZSTRL(tmp, str, length, type, duplicate); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_assoc_utf8_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate) -{ - zval *tmp; - TSRMLS_FETCH(); - - MAKE_STD_ZVAL(tmp); - ZVAL_UTF8_STRINGL(tmp, str, length, duplicate); - - return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_u_assoc_utf8_stringl_ex(zval *arg, zend_uchar type, zstr key, uint key_len, char *str, uint length, int duplicate) -{ - zval *tmp; - TSRMLS_FETCH(); - - MAKE_STD_ZVAL(tmp); - ZVAL_UTF8_STRINGL(tmp, str, length, duplicate); - - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &tmp, sizeof(zval *), NULL); -} - ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value) { return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &value, sizeof(zval *), NULL); } -ZEND_API int add_u_assoc_zval_ex(zval *arg, zend_uchar type, zstr key, uint key_len, zval *value) +ZEND_API int add_ascii_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value) { - return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &value, sizeof(zval *), NULL); + return zend_ascii_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void*)&value, sizeof(zval*), NULL); } -ZEND_API int add_index_long(zval *arg, ulong index, long n) +ZEND_API int add_rt_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value) { - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_LONG(tmp, n); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); + return zend_rt_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void*)&value, sizeof(zval*), NULL); } - -ZEND_API int add_index_null(zval *arg, ulong index) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_NULL(tmp); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - -ZEND_API int add_index_bool(zval *arg, ulong index, int b) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_BOOL(tmp, b); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_index_resource(zval *arg, ulong index, int r) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_RESOURCE(tmp, r); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_index_double(zval *arg, ulong index, double d) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_DOUBLE(tmp, d); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_index_string(zval *arg, ulong index, char *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRING(tmp, str, duplicate); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_index_stringl(zval *arg, ulong index, char *str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRINGL(tmp, str, length, duplicate); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_index_unicode(zval *arg, ulong index, UChar *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODE(tmp, str, duplicate); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_index_unicodel(zval *arg, ulong index, UChar *str, uint length, int duplicate) +ZEND_API int add_u_assoc_zval_ex(zval *arg, zend_uchar type, zstr key, uint key_len, zval *value) { - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODEL(tmp, str, length, duplicate); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); + return zend_u_symtable_update(Z_ARRVAL_P(arg), type, key, key_len, (void *) &value, sizeof(zval *), NULL); } - ZEND_API int add_index_zval(zval *arg, ulong index, zval *value) { return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &value, sizeof(zval *), NULL); } -ZEND_API int add_index_utf8_string(zval *arg, ulong index, char *str, int duplicate) -{ - zval *tmp; - TSRMLS_FETCH(); - - MAKE_STD_ZVAL(tmp); - ZVAL_UTF8_STRING(tmp, str, duplicate); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_index_utf8_stringl(zval *arg, ulong index, char *str, uint length, int duplicate) -{ - zval *tmp; - TSRMLS_FETCH(); - - MAKE_STD_ZVAL(tmp); - ZVAL_UTF8_STRINGL(tmp, str, length, duplicate); - - return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_long(zval *arg, long n) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_LONG(tmp, n); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_null(zval *arg) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_NULL(tmp); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_bool(zval *arg, int b) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_BOOL(tmp, b); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_resource(zval *arg, int r) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_RESOURCE(tmp, r); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_double(zval *arg, double d) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_DOUBLE(tmp, d); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_string(zval *arg, char *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRING(tmp, str, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_STRINGL(tmp, str, length, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_unicode(zval *arg, UChar *str, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODE(tmp, str, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_unicodel(zval *arg, UChar *str, uint length, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_UNICODEL(tmp, str, length, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_utf8_string(zval *arg, char *str, int duplicate) -{ - zval *tmp; - TSRMLS_FETCH(); - - MAKE_STD_ZVAL(tmp); - ZVAL_UTF8_STRING(tmp, str, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_utf8_stringl(zval *arg, char *str, uint length, int duplicate) -{ - zval *tmp; - TSRMLS_FETCH(); - - MAKE_STD_ZVAL(tmp); - ZVAL_UTF8_STRINGL(tmp, str, length, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_zstr(zval *arg, zstr str, zend_uchar type, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_ZSTR(tmp, str, type, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - -ZEND_API int add_next_index_zstrl(zval *arg, zstr str, uint length, zend_uchar type, int duplicate) -{ - zval *tmp; - - MAKE_STD_ZVAL(tmp); - ZVAL_ZSTRL(tmp, str, length, type, duplicate); - - return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL); -} - - ZEND_API int add_next_index_zval(zval *arg, zval *value) { return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &value, sizeof(zval *), NULL); @@ -2845,7 +2354,7 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length, va_start(symbol_table_list, num_symbol_tables); while (num_symbol_tables-- > 0) { symbol_table = va_arg(symbol_table_list, HashTable *); - zend_hash_update(symbol_table, name, name_length + 1, &symbol, sizeof(zval *), NULL); + zend_rt_hash_update(symbol_table, name, name_length + 1, &symbol, sizeof(zval *), NULL); zval_add_ref(&symbol); } va_end(symbol_table_list); diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 4211344983..64e2b5cc5a 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -323,90 +323,131 @@ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destro /* no longer supported */ ZEND_API int add_assoc_function(zval *arg, char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS)); -ZEND_API int add_assoc_long_ex(zval *arg, char *key, uint key_len, long n); -ZEND_API int add_assoc_null_ex(zval *arg, char *key, uint key_len); -ZEND_API int add_assoc_bool_ex(zval *arg, char *key, uint key_len, int b); -ZEND_API int add_assoc_resource_ex(zval *arg, char *key, uint key_len, int r); -ZEND_API int add_assoc_double_ex(zval *arg, char *key, uint key_len, double d); -ZEND_API int add_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, int duplicate); -ZEND_API int add_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate); -ZEND_API int add_assoc_unicode_ex(zval *arg, char *key, uint key_len, UChar *str, int duplicate); -ZEND_API int add_assoc_unicodel_ex(zval *arg, char *key, uint key_len, UChar *str, uint length, int duplicate); -ZEND_API int add_assoc_zstr_ex(zval *arg, char *key, uint key_len, zend_uchar str_type, zstr str, int duplicate); -ZEND_API int add_assoc_zstrl_ex(zval *arg, char *key, uint key_len, zend_uchar str_type, zstr str, uint str_len, int duplicate); -ZEND_API int add_assoc_utf8_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate); -ZEND_API int add_u_assoc_utf8_stringl_ex(zval *arg, zend_uchar type, zstr key, uint key_len, char *str, uint length, int duplicate); -ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value); - #define ZSTR_DUPLICATE (1<<0) #define ZSTR_AUTOFREE (1<<1) -#define add_assoc_text_ex(arg, key, key_len, str, duplicate) \ - if (UG(unicode)) { \ - add_assoc_unicode_ex(arg, key, key_len, (str).u, duplicate); \ - } else { \ - add_assoc_string_ex(arg, key, key_len, (str).s, duplicate); \ - } - -#define add_assoc_textl_ex(arg, key, key_len, str, length, duplicate) \ - if (UG(unicode)) { \ - add_assoc_unicodel_ex(arg, key, key_len, (str).u, length, duplicate); \ - } else { \ - add_assoc_stringl_ex(arg, key, key_len, (str).s, length, duplicate); \ - } +ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value); -#define add_assoc_ascii_string_ex(arg, key, key_len, str, flags) \ - if (UG(unicode)) { \ - uint length = strlen(str); \ - UChar *u_str = zend_ascii_to_unicode((str), length+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ +#define add_assoc_null_ex(arg, key, key_len) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_NULL(___tmp); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_long_ex(arg, key, key_len, n) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_LONG(___tmp, n); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_bool_ex(arg, key, key_len, b) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_BOOL(___tmp, b); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_resource_ex(arg, key, key_len, r) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_RESOURCE(___tmp, r); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_double_ex(arg, key, key_len, d) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_DOUBLE(___tmp, d); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_stringl_ex(arg, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_STRINGL(___tmp, str, length, duplicate); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_unicode_ex(arg, key, key_len, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODE(___tmp, str, duplicate); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_unicodel_ex(arg, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODEL(___tmp, str, length, duplicate); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_zstr_ex(arg, key, key_len, type, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTR(___tmp, str, type, duplicate); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_zstrl_ex(arg, key, key_len, type, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTRL(___tmp, str, length, type, duplicate); \ + add_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_assoc_text_ex(arg, key, key_len, str, duplicate) do { \ + if (UG(unicode)) { \ + add_assoc_unicode_ex(arg, key, key_len, (str).u, duplicate); \ + } else { \ + add_assoc_string_ex(arg, key, key_len, (str).s, duplicate); \ } \ - add_assoc_unicodel_ex(arg, key, key_len, u_str, length, 0); \ - } else { \ - add_assoc_string_ex(arg, key, key_len, (char*)(str), (flags) & ZSTR_DUPLICATE); \ - } - -#define add_assoc_ascii_stringl_ex(arg, key, key_len, str, length, flags) \ - if (UG(unicode)) { \ - UChar *u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ + } while (0) +#define add_assoc_textl_ex(arg, key, key_len, str, length, duplicate) do { \ + if (UG(unicode)) { \ + add_assoc_unicodel_ex(arg, key, key_len, (str).u, length, duplicate); \ + } else { \ + add_assoc_stringl_ex(arg, key, key_len, (str).s, length, duplicate); \ } \ - add_assoc_unicodel_ex(arg, key, key_len, u_str, length, 0); \ - } else { \ - add_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ - } + } while (0) -#define add_assoc_rt_string_ex(arg, key, key_len, str, flags) \ - if (UG(unicode)) { \ - UErrorCode status = U_ZERO_ERROR; \ - UChar *u_str; \ - int u_len; \ - int length = strlen(str); \ - zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u_str, &u_len, str, length, &status); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ +#define add_assoc_ascii_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UChar *___u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_assoc_unicodel_ex(arg, key, key_len, ___u_str, length, 0); \ + } else { \ + add_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ } \ - add_assoc_unicodel_ex(arg, key, key_len, u_str, u_len, 0); \ - } else { \ - add_assoc_string_ex(arg, key, key_len, (char*)(str), (flags) & ZSTR_DUPLICATE); \ - } - -#define add_assoc_rt_stringl_ex(arg, key, key_len, str, length, flags) \ - if (UG(unicode)) { \ - UErrorCode status = U_ZERO_ERROR; \ - UChar *u_str; \ - int u_len; \ - zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u_str, &u_len, str, length, &status); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ + } while (0) +#define add_assoc_rt_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_assoc_unicodel_ex(arg, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ } \ - add_assoc_unicodel_ex(arg, key, key_len, u_str, u_len, 0); \ - } else { \ - add_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ - } + } while (0) +#define add_assoc_utf8_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(UG(utf8_conv), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_assoc_unicodel_ex(arg, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) +#define add_assoc_string_ex(arg, key, key_len, str, flags) add_assoc_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_assoc_ascii_string_ex(arg, key, key_len, str, flags) add_assoc_ascii_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_assoc_rt_string_ex(arg, key, key_len, str, flags) add_assoc_rt_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_assoc_utf8_string_ex(arg, key, key_len, str, flags) add_assoc_utf8_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value) #define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key)+1, __n) #define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1) #define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b) @@ -418,206 +459,693 @@ ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value); #define add_assoc_unicodel(__arg, __key, __str, __length, __duplicate) add_assoc_unicodel_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) #define add_assoc_zstr(__arg, __key, __type, __str, __duplicate) add_assoc_zstr_ex(__arg, __key, strlen(__key)+1, __type, __str, __duplicate) #define add_assoc_zstrl(__arg, __key, __type, __str, __length, __duplicate) add_assoc_zstrl_ex(__arg, __key, strlen(__key)+1, __type, __str, __length, __duplicate) -#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value) +#define add_assoc_ascii_string(arg, key, str, flags) add_assoc_ascii_string_ex(arg, key, strlen(key)+1, str, flags) +#define add_assoc_ascii_stringl(arg, key, str, length, flags) add_assoc_ascii_stringl_ex(arg, key, strlen(key)+1, str, length, flags) #define add_assoc_rt_string(__arg, __key, __str, __duplicate) add_assoc_rt_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) #define add_assoc_rt_stringl(__arg, __key, __str, __length, __duplicate) add_assoc_rt_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) #define add_assoc_utf8_string(__arg, __key, __str, __duplicate) add_assoc_utf8_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) #define add_assoc_utf8_stringl(__arg, __key, __str, __length, __duplicate) add_assoc_utf8_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) +#define add_assoc_text(arg, key, str, duplicate) add_assoc_text_ex(arg, key, strlen(key)+1, str, duplicate) +#define add_assoc_textl(arg, key, str, length, duplicate) add_assoc_textl_ex(arg, key, strlen(key)+1, str, length, duplicate) + +ZEND_API int add_ascii_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value); + +#define add_ascii_assoc_null_ex(arg, key, key_len) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_NULL(___tmp); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_long_ex(arg, key, key_len, n) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_LONG(___tmp, n); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_bool_ex(arg, key, key_len, b) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_BOOL(___tmp, b); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_resource_ex(arg, key, key_len, r) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_RESOURCE(___tmp, r); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_double_ex(arg, key, key_len, d) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_DOUBLE(___tmp, d); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_stringl_ex(arg, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_STRINGL(___tmp, str, length, duplicate); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_unicode_ex(arg, key, key_len, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODE(___tmp, str, duplicate); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_unicodel_ex(arg, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODEL(___tmp, str, length, duplicate); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_zstr_ex(arg, key, key_len, type, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTR(___tmp, str, type, duplicate); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_zstrl_ex(arg, key, key_len, type, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTRL(___tmp, str, length, type, duplicate); \ + add_ascii_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_ascii_assoc_text_ex(arg, key, key_len, str, duplicate) do { \ + if (UG(unicode)) { \ + add_ascii_assoc_unicode_ex(arg, key, key_len, (str).u, duplicate); \ + } else { \ + add_ascii_assoc_string_ex(arg, key, key_len, (str).s, duplicate); \ + } \ + } while (0) +#define add_ascii_assoc_textl_ex(arg, key, key_len, str, length, duplicate) do { \ + if (UG(unicode)) { \ + add_ascii_assoc_unicodel_ex(arg, key, key_len, (str).u, length, duplicate); \ + } else { \ + add_ascii_assoc_stringl_ex(arg, key, key_len, (str).s, length, duplicate); \ + } \ + } while (0) -#define add_assoc_text(arg, key, str, duplicate) \ - if (UG(unicode)) { \ - add_assoc_unicode(arg, key, (str).u, duplicate); \ - } else { \ - add_assoc_string(arg, key, (str).s, duplicate); \ - } - -#define add_assoc_textl(arg, key, str, length, duplicate) \ - if (UG(unicode)) { \ - add_assoc_unicodel(arg, key, (str).u, length, duplicate); \ - } else { \ - add_assoc_stringl(arg, key, (str).s, length, duplicate); \ - } - -#define add_assoc_ascii_string(arg, key, str, flags) \ - if (UG(unicode)) { \ - uint length = strlen(str); \ - UChar *u_str = zend_ascii_to_unicode((str), length+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ +#define add_ascii_assoc_ascii_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UChar *___u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_ascii_assoc_unicodel_ex(arg, key, key_len, ___u_str, length, 0); \ + } else { \ + add_ascii_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ } \ - add_assoc_unicodel(arg, key, u_str, length, 0); \ - } else { \ - add_assoc_string(arg, key, (char*)(str), (flags) & ZSTR_DUPLICATE); \ - } + } while (0) +#define add_ascii_assoc_rt_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_ascii_assoc_unicodel_ex(arg, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_ascii_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) +#define add_ascii_assoc_utf8_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(UG(utf8_conv), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_ascii_assoc_unicodel_ex(arg, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_ascii_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) + +#define add_ascii_assoc_string_ex(arg, key, key_len, str, flags) add_ascii_assoc_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_ascii_assoc_ascii_string_ex(arg, key, key_len, str, flags) add_ascii_assoc_ascii_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_ascii_assoc_rt_string_ex(arg, key, key_len, str, flags) add_ascii_assoc_rt_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_ascii_assoc_utf8_string_ex(arg, key, key_len, str, flags) add_ascii_assoc_utf8_stringl_ex(arg, key, key_len, str, strlen(str), flags) + +#define add_ascii_assoc_zval(__arg, __key, __value) add_ascii_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value) +#define add_ascii_assoc_long(__arg, __key, __n) add_ascii_assoc_long_ex(__arg, __key, strlen(__key)+1, __n) +#define add_ascii_assoc_null(__arg, __key) add_ascii_assoc_null_ex(__arg, __key, strlen(__key)+1) +#define add_ascii_assoc_bool(__arg, __key, __b) add_ascii_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b) +#define add_ascii_assoc_resource(__arg, __key, __r) add_ascii_assoc_resource_ex(__arg, __key, strlen(__key)+1, __r) +#define add_ascii_assoc_double(__arg, __key, __d) add_ascii_assoc_double_ex(__arg, __key, strlen(__key)+1, __d) +#define add_ascii_assoc_string(__arg, __key, __str, __duplicate) add_ascii_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) +#define add_ascii_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_ascii_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) +#define add_ascii_assoc_unicode(__arg, __key, __str, __duplicate) add_ascii_assoc_unicode_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) +#define add_ascii_assoc_unicodel(__arg, __key, __str, __length, __duplicate) add_ascii_assoc_unicodel_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) +#define add_ascii_assoc_zstr(arg, key, type, str, duplicate) add_ascii_assoc_zstr_ex(arg, key, strlen(key)+1, type, str, duplicate) +#define add_ascii_assoc_zstrl(arg, key, type, str, length, duplicate) add_ascii_assoc_zstrl_ex(arg, key, strlen(key)+1, type, str, length, duplicate) +#define add_ascii_assoc_ascii_string(arg, key, str, flags) add_ascii_assoc_ascii_string_ex(arg, key, strlen(key)+1, str, flags) +#define add_ascii_assoc_ascii_stringl(arg, key, str, length, flags) add_ascii_assoc_ascii_stringl_ex(arg, key, strlen(key)+1, str, length, flags) +#define add_ascii_assoc_rt_string(arg, key, str, flags) add_ascii_assoc_rt_stringl_ex(arg, key, strlen(key)+1, str, strlen(str), flags) +#define add_ascii_assoc_rt_stringl(arg, key, str, length, flags) add_ascii_assoc_rt_stringl_ex(arg, key, strlen(key)+1, str, length, flags) +#define add_ascii_assoc_utf8_string(arg, key, str, flags) add_ascii_assoc_utf8_stringl_ex(arg, key, strlen(key)+1, str, strlen(str), flags) +#define add_ascii_assoc_utf8_stringl(arg, key, str, length, flags) add_ascii_assoc_utf8_stringl_ex(arg, key, strlen(key)+1, str, length, flags) +#define add_ascii_assoc_text(__arg, __key, __str, __duplicate) add_ascii_assoc_test_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) +#define add_ascii_assoc_textl(__arg, __key, __str, __length, __duplicate) add_ascii_assoc_textl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) + +ZEND_API int add_rt_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value); + +#define add_rt_assoc_null_ex(arg, key, key_len) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_NULL(___tmp); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_long_ex(arg, key, key_len, n) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_LONG(___tmp, n); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_bool_ex(arg, key, key_len, b) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_BOOL(___tmp, b); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_resource_ex(arg, key, key_len, r) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_RESOURCE(___tmp, r); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_double_ex(arg, key, key_len, d) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_DOUBLE(___tmp, d); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_stringl_ex(arg, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_STRINGL(___tmp, str, length, duplicate); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_unicode_ex(arg, key, key_len, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODE(___tmp, str, duplicate); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_unicodel_ex(arg, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODEL(___tmp, str, length, duplicate); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_zstr_ex(arg, key, key_len, type, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTR(___tmp, str, type, duplicate); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_zstrl_ex(arg, key, key_len, type, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTRL(___tmp, str, length, type, duplicate); \ + add_rt_assoc_zval_ex(arg, key, key_len, ___tmp); \ + } while (0) +#define add_rt_assoc_text_ex(arg, key, key_len, str, duplicate) do { \ + if (UG(unicode)) { \ + add_rt_assoc_unicode_ex(arg, key, key_len, (str).u, duplicate); \ + } else { \ + add_rt_assoc_string_ex(arg, key, key_len, (str).s, duplicate); \ + } \ + } while (0) +#define add_rt_assoc_textl_ex(arg, key, key_len, str, length, duplicate) do { \ + if (UG(unicode)) { \ + add_rt_assoc_unicodel_ex(arg, key, key_len, (str).u, length, duplicate); \ + } else { \ + add_rt_assoc_stringl_ex(arg, key, key_len, (str).s, length, duplicate); \ + } \ + } while (0) -#define add_assoc_ascii_stringl(arg, key, str, length, flags) \ - if (UG(unicode)) { \ - UChar *u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ +#define add_rt_assoc_ascii_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UChar *___u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_rt_assoc_unicodel_ex(arg, key, key_len, ___u_str, length, 0); \ + } else { \ + add_rt_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ } \ - add_assoc_unicodel(arg, key, u_str, length, 0); \ - } else { \ - add_assoc_stringl(arg, key, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ - } + } while (0) +#define add_rt_assoc_rt_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_rt_assoc_unicodel_ex(arg, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_rt_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) +#define add_rt_assoc_utf8_stringl_ex(arg, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(UG(utf8_conv), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_rt_assoc_unicodel_ex(arg, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_rt_assoc_stringl_ex(arg, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) + +#define add_rt_assoc_string_ex(arg, key, key_len, str, flags) add_rt_assoc_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_rt_assoc_ascii_string_ex(arg, key, key_len, str, flags) add_rt_assoc_ascii_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_rt_assoc_rt_string_ex(arg, key, key_len, str, flags) add_rt_assoc_rt_stringl_ex(arg, key, key_len, str, strlen(str), flags) +#define add_rt_assoc_utf8_string_ex(arg, key, key_len, str, flags) add_rt_assoc_utf8_stringl_ex(arg, key, key_len, str, strlen(str), flags) + +#define add_rt_assoc_zval(__arg, __key, __value) add_rt_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value) +#define add_rt_assoc_long(__arg, __key, __n) add_rt_assoc_long_ex(__arg, __key, strlen(__key)+1, __n) +#define add_rt_assoc_null(__arg, __key) add_rt_assoc_null_ex(__arg, __key, strlen(__key)+1) +#define add_rt_assoc_bool(__arg, __key, __b) add_rt_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b) +#define add_rt_assoc_resource(__arg, __key, __r) add_rt_assoc_resource_ex(__arg, __key, strlen(__key)+1, __r) +#define add_rt_assoc_double(__arg, __key, __d) add_rt_assoc_double_ex(__arg, __key, strlen(__key)+1, __d) +#define add_rt_assoc_string(__arg, __key, __str, __duplicate) add_rt_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) +#define add_rt_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_rt_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) +#define add_rt_assoc_unicode(__arg, __key, __str, __duplicate) add_rt_assoc_unicode_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) +#define add_rt_assoc_unicodel(__arg, __key, __str, __length, __duplicate) add_rt_assoc_unicodel_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) +#define add_rt_assoc_zstr(arg, key, type, str, duplicate) add_rt_assoc_zstr_ex(arg, key, strlen(key)+1, type, str, duplicate) +#define add_rt_assoc_zstrl(arg, key, type, str, length, duplicate) add_rt_assoc_zstrl_ex(arg, key, strlen(key)+1, type, str, length, duplicate) +#define add_rt_assoc_ascii_string(arg, key, str, flags) add_rt_assoc_ascii_string_ex(arg, key, strlen(key)+1, str, flags) +#define add_rt_assoc_ascii_stringl(arg, key, str, length, flags) add_rt_assoc_ascii_stringl_ex(arg, key, strlen(key)+1, str, length, flags) +#define add_rt_assoc_rt_string(arg, key, str, flags) add_rt_assoc_rt_stringl_ex(arg, key, strlen(key)+1, str, strlen(str), flags) +#define add_rt_assoc_rt_stringl(arg, key, str, length, flags) add_rt_assoc_rt_stringl_ex(arg, key, strlen(key)+1, str, length, flags) +#define add_rt_assoc_utf8_string(arg, key, str, flags) add_rt_assoc_utf8_stringl_ex(arg, key, strlen(key)+1, str, strlen(str), flags) +#define add_rt_assoc_utf8_stringl(arg, key, str, length, flags) add_rt_assoc_utf8_stringl_ex(arg, key, strlen(key)+1, str, length, flags) +#define add_rt_assoc_text(__arg, __key, __str, __duplicate) add_rt_assoc_test_ex(__arg, __key, strlen(__key)+1, __str, __duplicate) +#define add_rt_assoc_textl(__arg, __key, __str, __length, __duplicate) add_rt_assoc_textl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate) -ZEND_API int add_u_assoc_long_ex(zval *arg, zend_uchar type, zstr key, uint key_len, long n); -ZEND_API int add_u_assoc_null_ex(zval *arg, zend_uchar type, zstr key, uint key_len); -ZEND_API int add_u_assoc_bool_ex(zval *arg, zend_uchar type, zstr key, uint key_len, int b); -ZEND_API int add_u_assoc_resource_ex(zval *arg, zend_uchar type, zstr key, uint key_len, int r); -ZEND_API int add_u_assoc_double_ex(zval *arg, zend_uchar type, zstr key, uint key_len, double d); -ZEND_API int add_u_assoc_string_ex(zval *arg, zend_uchar type, zstr key, uint key_len, char *str, int duplicate); -ZEND_API int add_u_assoc_stringl_ex(zval *arg, zend_uchar type, zstr key, uint key_len, char *str, uint length, int duplicate); -ZEND_API int add_u_assoc_unicode_ex(zval *arg, zend_uchar type, zstr key, uint key_len, UChar *str, int duplicate); -ZEND_API int add_u_assoc_unicodel_ex(zval *arg, zend_uchar type, zstr key, uint key_len, UChar *str, uint length, int duplicate); ZEND_API int add_u_assoc_zval_ex(zval *arg, zend_uchar type, zstr key, uint key_len, zval *value); -#define add_u_assoc_long(__arg, __type, __key, __n) add_u_assoc_long_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __n) -#define add_u_assoc_null(__arg, __type, __key) add_u_assoc_null_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1) -#define add_u_assoc_bool(__arg, __type, __key, __b) add_u_assoc_bool_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __b) -#define add_u_assoc_resource(__arg, __type, __key, __r) add_u_assoc_resource_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __r) -#define add_u_assoc_double(__arg, __type, __key, __d) add_u_assoc_double_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __d) -#define add_u_assoc_string(__arg, __type, __key, __str, __duplicate) add_u_assoc_string_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __str, __duplicate) -#define add_u_assoc_stringl(__arg, __type, __key, __str, __length, __duplicate) add_u_assoc_stringl_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __str, __length, __duplicate) -#define add_u_assoc_unicode(__arg, __type, __key, __str, __duplicate) add_u_assoc_unicode_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __str, __duplicate) -#define add_u_assoc_unicodel(__arg, __type, __key, __str, __length, __duplicate) add_u_assoc_unicodel_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __str, __length, __duplicate) -#define add_u_assoc_zval(__arg, __type, __key, __value) add_u_assoc_zval_ex(__arg, __type, __key, (((__type)==IS_UNICODE)?u_strlen((__key).u):strlen((__key).s))+1, __value) +#define add_u_assoc_null_ex(arg, type, key, key_len) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_NULL(___tmp); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_long_ex(arg, type, key, key_len, n) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_LONG(___tmp, n); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_bool_ex(arg, type, key, key_len, b) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_BOOL(___tmp, b); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_resource_ex(arg, type, key, key_len, r) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_RESOURCE(___tmp, r); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_double_ex(arg, type, key, key_len, d) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_DOUBLE(___tmp, d); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_stringl_ex(arg, type, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_STRINGL(___tmp, str, length, duplicate); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_unicode_ex(arg, type, key, key_len, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODE(___tmp, str, duplicate); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_unicodel_ex(arg, type, key, key_len, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODEL(___tmp, str, length, duplicate); \ + add_u_assoc_zval_ex(arg, type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_zstr_ex(arg, key_type, key, key_len, type, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTR(___tmp, str, type, duplicate); \ + add_u_assoc_zval_ex(arg, key_type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_zstrl_ex(arg, key_type, key, key_len, type, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTRL(___tmp, str, length, type, duplicate); \ + add_u_assoc_zval_ex(arg, key_type, key, key_len, ___tmp); \ + } while (0) +#define add_u_assoc_text_ex(arg, type, key, key_len, str, duplicate) do { \ + if (UG(unicode)) { \ + add_u_assoc_unicode_ex(arg, type, key, key_len, (str).u, duplicate); \ + } else { \ + add_u_assoc_string_ex(arg, type, key, key_len, (str).s, duplicate); \ + } \ + } while (0) +#define add_u_assoc_textl_ex(arg, type, key, key_len, str, length, duplicate) do { \ + if (UG(unicode)) { \ + add_u_assoc_unicodel_ex(arg, type, key, key_len, (str).u, length, duplicate); \ + } else { \ + add_u_assoc_stringl_ex(arg, type, key, key_len, (str).s, length, duplicate); \ + } \ + } while (0) -/* unset() functions are only suported for legacy modules and null() functions should be used */ -#define add_assoc_unset(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1) -#define add_index_unset(__arg, __key) add_index_null(__arg, __key) -#define add_next_index_unset(__arg) add_next_index_null(__arg) -#define add_property_unset(__arg, __key) add_property_null(__arg, __key) +#define add_u_assoc_ascii_stringl_ex(arg, type, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UChar *___u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_u_assoc_unicodel_ex(arg, type, key, key_len, ___u_str, length, 0); \ + } else { \ + add_u_assoc_stringl_ex(arg, type, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) +#define add_u_assoc_rt_stringl_ex(arg, type, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_u_assoc_unicodel_ex(arg, type, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_u_assoc_stringl_ex(arg, type, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) +#define add_u_assoc_utf8_stringl_ex(arg, type, key, key_len, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(UG(utf8_conv), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_u_assoc_unicodel_ex(arg, type, key, key_len, ___u_str, ___u_len, 0); \ + } else { \ + add_u_assoc_stringl_ex(arg, type, key, key_len, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) + +#define add_u_assoc_string_ex(arg, key_type, key, key_len, str, flags) add_u_assoc_stringl_ex(arg, key_type, key, key_len, str, strlen(str), flags) +#define add_u_assoc_ascii_string_ex(arg, key_type, key, key_len, str, flags) add_u_assoc_ascii_stringl_ex(arg, key_type, key, key_len, str, strlen(str), flags) +#define add_u_assoc_rt_string_ex(arg, key_type, key, key_len, str, flags) add_u_assoc_rt_stringl_ex(arg, key_type, key, key_len, str, strlen(str), flags) +#define add_u_assoc_utf8_string_ex(arg, key_type, key, key_len, str, flags) add_u_assoc_utf8_stringl_ex(arg, key_type, key, key_len, str, strlen(str), flags) + +#define add_u_assoc_zval(__arg, __key_type, __key, __value) add_u_assoc_zval_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __value) +#define add_u_assoc_long(__arg, __key_type, __key, __n) add_u_assoc_long_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __n) +#define add_u_assoc_null(__arg, __key_type, __key) add_u_assoc_null_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1+1) +#define add_u_assoc_bool(__arg, __key_type, __key, __b) add_u_assoc_bool_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __b) +#define add_u_assoc_resource(__arg, __key_type, __key, __r) add_u_assoc_resource_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __r) +#define add_u_assoc_double(__arg, __key_type, __key, __d) add_u_assoc_double_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __d) +#define add_u_assoc_string(__arg, __key_type, __key, __str, __duplicate) add_u_assoc_string_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __str, __duplicate) +#define add_u_assoc_stringl(__arg, __key_type, __key, __str, __length, __duplicate) add_u_assoc_stringl_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __str, __length, __duplicate) +#define add_u_assoc_unicode(__arg, __key_type, __key, __str, __duplicate) add_u_assoc_unicode_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __str, __duplicate) +#define add_u_assoc_unicodel(__arg, __key_type, __key, __str, __length, __duplicate) add_u_assoc_unicodel_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __str, __length, __duplicate) +#define add_u_assoc_zstr(arg, key_type, key, type, str, duplicate) add_u_assoc_zstr_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, type, str, duplicate) +#define add_u_assoc_zstrl(arg, key_type, key, type, str, length, duplicate) add_u_assoc_zstrl_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, type, str, length, duplicate) +#define add_u_assoc_ascii_string(arg, key_type, key, str, flags) add_u_assoc_ascii_string_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, str, flags) +#define add_u_assoc_ascii_stringl(arg, key_type, key, str, length, flags) add_u_assoc_ascii_stringl_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, str, length, flags) +#define add_u_assoc_rt_string(arg, key_type, key, str, flags) add_rt_assoc_u_stringl_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, str, strlen(str), flags) +#define add_u_assoc_rt_stringl(arg, key_type, key, str, length, flags) add_u_assoc_rt_stringl_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, str, length, flags) +#define add_u_assoc_utf8_string(arg, key_type, key, str, flags) add_u_assoc_utf8_stringl_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, str, strlen(str), flags) +#define add_u_assoc_utf8_stringl(arg, key_type, key, str, length, flags) add_u_assoc_utf8_stringl_ex(arg, key_type, key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, str, length, flags) +#define add_u_assoc_text(__arg, __key_type, __key, __str, __duplicate) add_u_assoc_test_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __str, __duplicate) +#define add_u_assoc_textl(__arg, __key_type, __key, __str, __length, __duplicate) add_u_assoc_textl_ex(__arg, __key_type, __key, ((__key_type==IS_UNICODE)?u_strlen(__key.u):strlen(__key.s))+1, __str, __length, __duplicate) -ZEND_API int add_index_long(zval *arg, ulong idx, long n); -ZEND_API int add_index_null(zval *arg, ulong idx); -ZEND_API int add_index_bool(zval *arg, ulong idx, int b); -ZEND_API int add_index_resource(zval *arg, ulong idx, int r); -ZEND_API int add_index_double(zval *arg, ulong idx, double d); -ZEND_API int add_index_string(zval *arg, ulong idx, char *str, int duplicate); -ZEND_API int add_index_stringl(zval *arg, ulong idx, char *str, uint length, int duplicate); -ZEND_API int add_index_unicode(zval *arg, ulong idx, UChar *str, int duplicate); -ZEND_API int add_index_unicodel(zval *arg, ulong idx, UChar *str, uint length, int duplicate); -ZEND_API int add_index_utf8_stringl(zval *arg, ulong index, char *str, uint length, int duplicate); ZEND_API int add_index_zval(zval *arg, ulong index, zval *value); -#define add_index_text(arg, idx, str, duplicate) \ - if (UG(unicode)) { \ - add_index_unicode(arg, idx, (str).u, duplicate); \ - } else { \ - add_index_string(arg, idx, (str).s, duplicate); \ - } - -#define add_index_textl(arg, idx, str, length, duplicate) \ - if (UG(unicode)) { \ - add_index_unicodel(arg, idx, (str).u, length, duplicate); \ - } else { \ - add_index_stringl(arg, idx, (str).s, length, duplicate); \ - } - -#define add_index_ascii_string(arg, idx, str, flags) \ - if (UG(unicode)) { \ - uint length = strlen(str); \ - UChar *u_str = zend_ascii_to_unicode((str), length+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ +#define add_index_null(arg, idx) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_NULL(___tmp); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_long(arg, idx, n) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_LONG(___tmp, n); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_bool(arg, idx, b) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_BOOL(___tmp, b); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_resource(arg, idx, r) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_RESOURCE(___tmp, r); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_double(arg, idx, d) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_DOUBLE(___tmp, d); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_stringl(arg, idx, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_STRINGL(___tmp, str, length, duplicate); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_unicode(arg, idx, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODE(___tmp, str, duplicate); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_unicodel(arg, idx, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODEL(___tmp, str, length, duplicate); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_zstr(arg, idx, type, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTR(___tmp, str, type, duplicate); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_zstrl(arg, idx, type, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTRL(___tmp, str, length, type, duplicate); \ + add_index_zval(arg, idx, ___tmp); \ + } while (0) +#define add_index_text(arg, idx, str, duplicate) do { \ + if (UG(unicode)) { \ + add_index_unicode(arg, idx, (str).u, duplicate); \ + } else { \ + add_index_string(arg, idx, (str).s, duplicate); \ } \ - add_index_unicodel(arg, idx, u_str, length, 0); \ - } else { \ - add_index_string(arg, idx, (char*)(str), (flags) & ZSTR_DUPLICATE); \ - } - -#define add_index_ascii_stringl(arg, idx, str, length, flags) \ - if (UG(unicode)) { \ - UChar *u_str = zend_ascii_to_unicode((str), length+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ + } while (0) +#define add_index_textl(arg, idx, str, length, duplicate) do { \ + if (UG(unicode)) { \ + add_index_unicodel(arg, idx, (str).u, length, duplicate); \ + } else { \ + add_index_stringl(arg, idx, (str).s, length, duplicate); \ } \ - add_index_unicodel(arg, idx, u_str, length, 0); \ - } else { \ - add_index_stringl(arg, idx, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ - } + } while (0) -ZEND_API int add_next_index_long(zval *arg, long n); -ZEND_API int add_next_index_null(zval *arg); -ZEND_API int add_next_index_bool(zval *arg, int b); -ZEND_API int add_next_index_resource(zval *arg, int r); -ZEND_API int add_next_index_double(zval *arg, double d); -ZEND_API int add_next_index_string(zval *arg, char *str, int duplicate); -ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate); -ZEND_API int add_next_index_unicode(zval *arg, UChar *str, int duplicate); -ZEND_API int add_next_index_unicodel(zval *arg, UChar *str, uint length, int duplicate); -ZEND_API int add_next_index_utf8_string(zval *arg, char *str, int duplicate); -ZEND_API int add_next_index_utf8_stringl(zval *arg, char *str, uint length, int duplicate); -ZEND_API int add_next_index_zstr(zval *arg, zstr str, zend_uchar type, int duplicate); -ZEND_API int add_next_index_zstrl(zval *arg, zstr str, uint length, zend_uchar type, int duplicate); -ZEND_API int add_next_index_zval(zval *arg, zval *value); +#define add_index_ascii_stringl(arg, idx, str, length, flags) do { \ + if (UG(unicode)) { \ + UChar *___u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_index_unicodel(arg, idx, ___u_str, length, 0); \ + } else { \ + add_index_stringl(arg, idx, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) +#define add_index_rt_stringl(arg, idx, str, length, flags) do {\ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_index_unicodel(arg, idx, ___u_str, ___u_len, 0); \ + } else { \ + add_index_stringl(arg, idx, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) +#define add_index_utf8_stringl(arg, idx, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(UG(utf8_conv), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_index_unicodel(arg, idx, ___u_str, ___u_len, 0); \ + } else { \ + add_index_stringl(arg, idx, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) -#define add_next_index_text(arg, str, duplicate) \ - if (UG(unicode)) { \ - add_next_index_unicode(arg, (str).u, duplicate); \ - } else { \ - add_next_index_string(arg, (str).s, duplicate); \ - } +#define add_index_string(arg, idx, str, flags) add_index_stringl(arg, idx, str, strlen(str), flags) +#define add_index_ascii_string(arg, idx, str, flags) add_index_ascii_stringl(arg, idx, str, strlen(str), flags) +#define add_index_rt_string(arg, idx, str, flags) add_index_rt_stringl(arg, idx, str, strlen(str), flags) +#define add_index_utf8_string(arg, idx, str, flags) add_index_utf8_stringl(arg, idx, str, strlen(str), flags) -#define add_next_index_textl(arg, str, length, duplicate) \ - if (UG(unicode)) { \ - add_next_index_unicodel(arg, (str).u, length, duplicate); \ - } else { \ - add_next_index_stringl(arg, (str).s, length, duplicate); \ - } +ZEND_API int add_next_index_zval(zval *arg, zval *value); -#define add_next_index_ascii_string(arg, str, flags) \ - if (UG(unicode)) { \ - uint length = strlen(str); \ - UChar *u_str = zend_ascii_to_unicode((str), length+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ +#define add_next_index_null(arg) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_NULL(___tmp); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_long(arg, n) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_LONG(___tmp, n); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_bool(arg, b) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_BOOL(___tmp, b); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_resource(arg, r) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_RESOURCE(___tmp, r); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_double(arg, d) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_DOUBLE(___tmp, d); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_stringl(arg, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_STRINGL(___tmp, str, length, duplicate); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_unicode(arg, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODE(___tmp, str, duplicate); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_unicodel(arg, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_UNICODEL(___tmp, str, length, duplicate); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_zstr(arg, type, str, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTR(___tmp, str, type, duplicate); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_zstrl(arg, type, str, length, duplicate) do { \ + zval *___tmp; \ + MAKE_STD_ZVAL(___tmp); \ + ZVAL_ZSTRL(___tmp, str, length, type, duplicate); \ + add_next_index_zval(arg, ___tmp); \ + } while (0) +#define add_next_index_text(arg, str, duplicate) do { \ + if (UG(unicode)) { \ + add_next_index_unicode(arg, (str).u, duplicate); \ + } else { \ + add_next_index_string(arg, (str).s, duplicate); \ } \ - add_next_index_unicodel(arg, u_str, length, 0); \ - } else { \ - add_next_index_string(arg, (char*)(str), (flags) & ZSTR_DUPLICATE); \ - } - -#define add_next_index_ascii_stringl(arg, str, length, flags) \ - if (UG(unicode)) { \ - UChar *u_str = zend_ascii_to_unicode((str), length+1 ZEND_FILE_LINE_CC); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ + } while (0) +#define add_next_index_textl(arg, str, length, duplicate) do { \ + if (UG(unicode)) { \ + add_next_index_unicodel(arg, (str).u, length, duplicate); \ + } else { \ + add_next_index_stringl(arg, (str).s, length, duplicate); \ } \ - add_next_index_unicodel(arg, u_str, length, 0); \ - } else { \ - add_next_index_stringl(arg, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ - } + } while (0) -#define add_next_index_rt_string(arg, str, flags) \ - if (UG(unicode)) { \ - UErrorCode status = U_ZERO_ERROR; \ - UChar *u_str; \ - int u_len; \ - int length = strlen(str); \ - zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u_str, &u_len, str, length, &status); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ +#define add_next_index_ascii_stringl(arg, str, length, flags) do { \ + if (UG(unicode)) { \ + UChar *___u_str = zend_ascii_to_unicode((str), (length)+1 ZEND_FILE_LINE_CC); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_next_index_unicodel(arg, ___u_str, length, 0); \ + } else { \ + add_next_index_stringl(arg, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ } \ - add_next_index_unicodel(arg, u_str, u_len, 0); \ - } else { \ - add_next_index_string(arg, (char*)(str), (flags) & ZSTR_DUPLICATE); \ - } - -#define add_next_index_rt_stringl(arg, str, length, flags) \ - if (UG(unicode)) { \ - UErrorCode status = U_ZERO_ERROR; \ - UChar *u_str; \ - int u_len; \ - zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u_str, &u_len, str, length, &status); \ - if ((flags) & ZSTR_AUTOFREE) { \ - efree(str); \ + } while (0) +#define add_next_index_rt_stringl(arg, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_next_index_unicodel(arg, ___u_str, ___u_len, 0); \ + } else { \ + add_next_index_stringl(arg, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ } \ - add_next_index_unicodel(arg, u_str, u_len, 0); \ - } else { \ - add_next_index_stringl(arg, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ - } + } while (0) +#define add_next_index_utf8_stringl(arg, str, length, flags) do { \ + if (UG(unicode)) { \ + UErrorCode ___status = U_ZERO_ERROR; \ + UChar *___u_str; \ + int ___u_len; \ + zend_string_to_unicode_ex(UG(utf8_conv), &___u_str, &___u_len, str, length, &___status); \ + if ((flags) & ZSTR_AUTOFREE) { \ + efree(str); \ + } \ + add_next_index_unicodel(arg, ___u_str, ___u_len, 0); \ + } else { \ + add_next_index_stringl(arg, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \ + } \ + } while (0) + +#define add_next_index_string(arg, str, flags) add_next_index_stringl(arg, str, strlen(str), flags) +#define add_next_index_ascii_string(arg, str, flags) add_next_index_ascii_stringl(arg, str, strlen(str), flags) +#define add_next_index_rt_string(arg, str, flags) add_next_index_rt_stringl(arg, str, strlen(str), flags) +#define add_next_index_utf8_string(arg, str, flags) add_next_index_utf8_stringl(arg, str, strlen(str), flags) + +/* unset() functions are only suported for legacy modules and null() functions should be used */ +#define add_assoc_unset(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1) +#define add_index_unset(__arg, __key) add_index_null(__arg, __key) +#define add_next_index_unset(__arg) add_next_index_null(__arg) +#define add_property_unset(__arg, __key) add_property_null(__arg, __key) ZEND_API int add_get_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, void **dest, int duplicate); ZEND_API int add_get_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, void **dest, int duplicate); @@ -1087,7 +1615,28 @@ END_EXTERN_C() } #define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref) \ - ZEND_U_SET_SYMBOL_WITH_LENGTH(symtable, IS_STRING, ZSTR(name), name_length, var, _refcount, _is_ref) + { \ + zval **orig_var; \ + \ + if (zend_rt_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS \ + && PZVAL_IS_REF(*orig_var)) { \ + (var)->refcount = (*orig_var)->refcount; \ + (var)->is_ref = 1; \ + \ + if (_refcount) { \ + (var)->refcount += _refcount-1; \ + } \ + zval_dtor(*orig_var); \ + **orig_var = *(var); \ + FREE_ZVAL(var); \ + } else { \ + (var)->is_ref = _is_ref; \ + if (_refcount) { \ + (var)->refcount = _refcount; \ + } \ + zend_rt_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL); \ + } \ + } #define ZEND_SET_GLOBAL_VAR(name, var) \ ZEND_SET_SYMBOL(&EG(symbol_table), name, var) diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 25ecb623e2..52fd6996e9 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -434,7 +434,7 @@ ZEND_FUNCTION(each) } zend_hash_index_update(Z_ARRVAL_P(return_value), 1, &entry, sizeof(zval *), NULL); entry->refcount++; - zend_hash_update(Z_ARRVAL_P(return_value), "value", sizeof("value"), &entry, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(return_value), "value", sizeof("value"), &entry, sizeof(zval *), NULL); entry->refcount++; /* add the key elements */ @@ -449,7 +449,7 @@ ZEND_FUNCTION(each) add_get_index_long(return_value, 0, num_key, (void **) &inserted_pointer); break; } - zend_hash_update(Z_ARRVAL_P(return_value), "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(return_value), "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL); (*inserted_pointer)->refcount++; zend_hash_move_forward(target_hash); } @@ -1476,12 +1476,12 @@ ZEND_FUNCTION(get_defined_functions) zend_hash_apply_with_arguments(EG(function_table), (apply_func_args_t) copy_function_name, 2, internal, user); - if (zend_hash_add(Z_ARRVAL_P(return_value), "internal", sizeof("internal"), (void **)&internal, sizeof(zval *), NULL) == FAILURE) { + if (zend_ascii_hash_add(Z_ARRVAL_P(return_value), "internal", sizeof("internal"), (void **)&internal, sizeof(zval *), NULL) == FAILURE) { zend_error(E_WARNING, "Cannot add internal functions to return value from get_defined_functions()"); RETURN_FALSE; } - if (zend_hash_add(Z_ARRVAL_P(return_value), "user", sizeof("user"), (void **)&user, sizeof(zval *), NULL) == FAILURE) { + if (zend_ascii_hash_add(Z_ARRVAL_P(return_value), "user", sizeof("user"), (void **)&user, sizeof(zval *), NULL) == FAILURE) { zend_error(E_WARNING, "Cannot add user functions to return value from get_defined_functions()"); RETURN_FALSE; } @@ -2035,8 +2035,8 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int if (skip->op_array) { filename = skip->op_array->filename; lineno = skip->opline->lineno; - add_assoc_rt_string_ex(stack_frame, "file", sizeof("file"), filename, 1); - add_assoc_long_ex(stack_frame, "line", sizeof("line"), lineno); + add_ascii_assoc_rt_string_ex(stack_frame, "file", sizeof("file"), filename, 1); + add_ascii_assoc_long_ex(stack_frame, "line", sizeof("line"), lineno); /* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function * and debug_baktrace() might have been called by the error_handler. in this case we don't @@ -2050,8 +2050,8 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int break; } if (prev->op_array) { - add_assoc_string_ex(stack_frame, "file", sizeof("file"), prev->op_array->filename, 1); - add_assoc_long_ex(stack_frame, "line", sizeof("line"), prev->opline->lineno); + add_ascii_assoc_string_ex(stack_frame, "file", sizeof("file"), prev->op_array->filename, 1); + add_ascii_assoc_long_ex(stack_frame, "line", sizeof("line"), prev->opline->lineno); break; } prev = prev->prev_execute_data; @@ -2062,32 +2062,32 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int function_name = ptr->function_state.function->common.function_name; if (function_name.v) { - add_assoc_text_ex(stack_frame, "function", sizeof("function"), function_name, 1); + add_ascii_assoc_text_ex(stack_frame, "function", sizeof("function"), function_name, 1); if (ptr->object && Z_TYPE_P(ptr->object) == IS_OBJECT) { if (ptr->function_state.function->common.scope) { - add_assoc_textl_ex(stack_frame, "class", sizeof("class"), ptr->function_state.function->common.scope->name, ptr->function_state.function->common.scope->name_length, 1); + add_ascii_assoc_textl_ex(stack_frame, "class", sizeof("class"), ptr->function_state.function->common.scope->name, ptr->function_state.function->common.scope->name_length, 1); } else { zend_uint class_name_len; int dup; dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC); - add_assoc_text_ex(stack_frame, "class", sizeof("class"), class_name, dup); + add_ascii_assoc_text_ex(stack_frame, "class", sizeof("class"), class_name, dup); } if (provide_object) { - add_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object); + add_ascii_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object); ptr->object->refcount++; } - add_assoc_ascii_string_ex(stack_frame, "type", sizeof("type"), "->", 1); + add_ascii_assoc_ascii_string_ex(stack_frame, "type", sizeof("type"), "->", 1); } else if (ptr->function_state.function->common.scope) { - add_assoc_textl_ex(stack_frame, "class", sizeof("class"), ptr->function_state.function->common.scope->name, ptr->function_state.function->common.scope->name_length, 1); - add_assoc_ascii_string_ex(stack_frame, "type", sizeof("type"), "::", 1); + add_ascii_assoc_textl_ex(stack_frame, "class", sizeof("class"), ptr->function_state.function->common.scope->name, ptr->function_state.function->common.scope->name_length, 1); + add_ascii_assoc_ascii_string_ex(stack_frame, "type", sizeof("type"), "::", 1); } if ((! ptr->opline) || ((ptr->opline->opcode == ZEND_DO_FCALL_BY_NAME) || (ptr->opline->opcode == ZEND_DO_FCALL))) { if (arg_stack_consistent && (frames_on_stack > 0)) { - add_assoc_zval_ex(stack_frame, "args", sizeof("args"), debug_backtrace_get_args(&cur_arg_pos TSRMLS_CC)); + add_ascii_assoc_zval_ex(stack_frame, "args", sizeof("args"), debug_backtrace_get_args(&cur_arg_pos TSRMLS_CC)); frames_on_stack--; } } @@ -2136,10 +2136,10 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int */ add_next_index_rt_string(arg_array, include_filename, 1); - add_assoc_zval_ex(stack_frame, "args", sizeof("args"), arg_array); + add_ascii_assoc_zval_ex(stack_frame, "args", sizeof("args"), arg_array); } - add_assoc_ascii_string_ex(stack_frame, "function", sizeof("function"), function_name.s, 1); + add_ascii_assoc_ascii_string_ex(stack_frame, "function", sizeof("function"), function_name.s, 1); } add_next_index_zval(return_value, stack_frame); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 35f4ddcc68..6552602812 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -3522,7 +3522,7 @@ void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr) zval_dtor(&offset->u.constant); break; case IS_NULL: - zend_symtable_update(Z_ARRVAL(result->u.constant), "", 1, &element, sizeof(zval *), NULL); + zend_u_symtable_update(Z_ARRVAL(result->u.constant), ZEND_STR_TYPE, EMPTY_ZSTR, 1, &element, sizeof(zval *), NULL); break; case IS_LONG: case IS_BOOL: diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 7d9d1739b6..bb09ff26c4 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -140,16 +140,8 @@ ZEND_METHOD(exception, __construct) if (message) { if (message_type == IS_UNICODE) { zend_update_property_unicodel(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC); - } else if (UG(unicode)) { - UErrorCode status = U_ZERO_ERROR; - UChar *u_str; - int u_len; - - zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u_str, &u_len, message, message_len, &status); - zend_update_property_unicodel(default_exception_ce, object, "message", sizeof("message")-1, u_str, u_len TSRMLS_CC); - efree(u_str); } else { - zend_update_property_stringl(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC); + zend_update_property_rt_stringl(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC); } } @@ -179,16 +171,8 @@ ZEND_METHOD(error_exception, __construct) if (message) { if (message_type == IS_UNICODE) { zend_update_property_unicodel(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC); - } else if (UG(unicode)) { - UErrorCode status = U_ZERO_ERROR; - UChar *u_str; - int u_len; - - zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u_str, &u_len, message, message_len, &status); - zend_update_property_unicodel(default_exception_ce, object, "message", sizeof("message")-1, u_str, u_len TSRMLS_CC); - efree(u_str); } else { - zend_update_property_stringl(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC); + zend_update_property_rt_stringl(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC); } } @@ -333,7 +317,7 @@ ZEND_METHOD(error_exception, getSeverity) TRACE_APPEND_STRL(val, sizeof(val)-1) #define TRACE_APPEND_KEY(key) \ - if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) { \ + if (zend_ascii_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) { \ if (Z_TYPE_PP(tmp) == IS_UNICODE) { \ zval copy; \ int use_copy; \ @@ -500,8 +484,8 @@ static int _build_trace_string(zval **frame, int num_args, va_list args, zend_ha sprintf(s_tmp, "#%d ", (*num)++); TRACE_APPEND_STRL(s_tmp, strlen(s_tmp)); efree(s_tmp); - if (zend_hash_find(ht, "file", sizeof("file"), (void**)&file) == SUCCESS) { - if (zend_hash_find(ht, "line", sizeof("line"), (void**)&tmp) == SUCCESS) { + if (zend_ascii_hash_find(ht, "file", sizeof("file"), (void**)&file) == SUCCESS) { + if (zend_ascii_hash_find(ht, "line", sizeof("line"), (void**)&tmp) == SUCCESS) { line = Z_LVAL_PP(tmp); } else { line = 0; @@ -518,7 +502,7 @@ static int _build_trace_string(zval **frame, int num_args, va_list args, zend_ha TRACE_APPEND_KEY("type"); TRACE_APPEND_KEY("function"); TRACE_APPEND_CHR('('); - if (zend_hash_find(ht, "args", sizeof("args"), (void**)&tmp) == SUCCESS) { + if (zend_ascii_hash_find(ht, "args", sizeof("args"), (void**)&tmp) == SUCCESS) { int last_len = *len; zend_hash_apply_with_arguments(Z_ARRVAL_PP(tmp), (apply_func_args_t)_build_trace_args, 2, str, len); if (last_len != *len) { diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index c6b332c5f6..95a7e1d430 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -170,7 +170,7 @@ void init_executor(TSRMLS_D) globals->is_ref=1; Z_TYPE_P(globals) = IS_ARRAY; Z_ARRVAL_P(globals) = &EG(symbol_table); - zend_hash_update(&EG(symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL); + zend_ascii_hash_update(&EG(symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL); } EG(active_symbol_table) = &EG(symbol_table); diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c index 3e0c07390a..44f3f37dff 100644 --- a/Zend/zend_hash.c +++ b/Zend/zend_hash.c @@ -47,6 +47,8 @@ (ht)->pInternalPointer = (element); \ } +#define ZEND_HASH_CVT_ERROR() zend_error(E_WARNING, "Could not convert String to Unicode") + #define UNICODE_KEY(ht, type, arKey, nKeyLength, tmp) \ if (ht->unicode && type == IS_STRING) { \ UErrorCode status = U_ZERO_ERROR; \ @@ -55,10 +57,11 @@ TSRMLS_FETCH(); \ zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u, &u_len, arKey.s, nKeyLength-1, &status); \ if (U_FAILURE(status)) { \ - /* UTODO: */ \ + ZEND_HASH_CVT_ERROR(); \ + } else { \ + type = IS_UNICODE; \ + tmp = arKey.u = u; \ } \ - type = IS_UNICODE; \ - tmp = arKey.u = u; \ } @@ -312,6 +315,48 @@ ZEND_API int _zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLengt return _zend_u_hash_add_or_update(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData, nDataSize, pDest, flag ZEND_FILE_LINE_CC); } +ZEND_API int _zend_ascii_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + + key.u = zend_ascii_to_unicode(arKey, nKeyLength ZEND_FILE_LINE_CC); + ret = _zend_u_hash_add_or_update(ht, IS_UNICODE, key, nKeyLength, pData, nDataSize, pDest, flag ZEND_FILE_LINE_CC); + efree(key.u); + return ret; + } else { + return _zend_u_hash_add_or_update(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData, nDataSize, pDest, flag ZEND_FILE_LINE_CC); + } +} + +ZEND_API int _zend_rt_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + UErrorCode status = U_ZERO_ERROR; + int u_len; + + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &key.u, &u_len, arKey, nKeyLength-1, &status); + if (U_FAILURE(status)) { + ZEND_HASH_CVT_ERROR(); + goto string_key; + } + + ret = _zend_u_hash_add_or_update(ht, IS_UNICODE, key, u_len+1, pData, nDataSize, pDest, flag ZEND_FILE_LINE_CC); + efree(key.u); + return ret; + } else { +string_key: + return _zend_u_hash_add_or_update(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData, nDataSize, pDest, flag ZEND_FILE_LINE_CC); + } +} + ZEND_API int _zend_u_hash_quick_add_or_update(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC) { uint nIndex; @@ -594,6 +639,47 @@ ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLen return zend_u_hash_del_key_or_index(ht, IS_STRING, ZSTR(arKey), nKeyLength, h, flag); } +ZEND_API int zend_ascii_hash_del(HashTable *ht, char *arKey, uint nKeyLength) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + + key.u = zend_ascii_to_unicode(arKey, nKeyLength ZEND_FILE_LINE_CC); + ret = zend_u_hash_del_key_or_index(ht, IS_UNICODE, key, nKeyLength, 0, HASH_DEL_KEY); + efree(key.u); + return ret; + } else { + return zend_u_hash_del_key_or_index(ht, IS_STRING, ZSTR(arKey), nKeyLength, 0, HASH_DEL_KEY); + } +} + +ZEND_API int zend_rt_hash_del(HashTable *ht, char *arKey, uint nKeyLength) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + UErrorCode status = U_ZERO_ERROR; + int u_len; + + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &key.u, &u_len, arKey, nKeyLength-1, &status); + if (U_FAILURE(status)) { + ZEND_HASH_CVT_ERROR(); + goto string_key; + } + ret = zend_u_hash_del_key_or_index(ht, IS_UNICODE, key, u_len+1, 0, HASH_DEL_KEY); + efree(key.u); + return ret; + } else { +string_key: + return zend_u_hash_del_key_or_index(ht, IS_STRING, ZSTR(arKey), nKeyLength, 0, HASH_DEL_KEY); + } +} + ZEND_API void zend_hash_destroy(HashTable *ht) { Bucket *p, *q; @@ -972,6 +1058,47 @@ ZEND_API int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void ** return zend_u_hash_find(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData); } +ZEND_API int zend_ascii_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + + key.u = zend_ascii_to_unicode(arKey, nKeyLength ZEND_FILE_LINE_CC); + ret = zend_u_hash_find(ht, IS_UNICODE, key, nKeyLength, pData); + efree(key.u); + return ret; + } else { + return zend_u_hash_find(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData); + } +} + +ZEND_API int zend_rt_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + UErrorCode status = U_ZERO_ERROR; + int u_len; + + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &key.u, &u_len, arKey, nKeyLength-1, &status); + if (U_FAILURE(status)) { + ZEND_HASH_CVT_ERROR(); + goto string_key; + } + ret = zend_u_hash_find(ht, IS_UNICODE, key, u_len+1, pData); + efree(key.u); + return ret; + } else { +string_key: + return zend_u_hash_find(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData); + } +} + ZEND_API int zend_u_hash_quick_find(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, ulong h, void **pData) { @@ -1051,6 +1178,47 @@ ZEND_API int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength) return zend_u_hash_exists(ht, IS_STRING, ZSTR(arKey), nKeyLength); } +ZEND_API int zend_ascii_hash_exists(HashTable *ht, char *arKey, uint nKeyLength) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + + key.u = zend_ascii_to_unicode(arKey, nKeyLength ZEND_FILE_LINE_CC); + ret = zend_u_hash_exists(ht, IS_UNICODE, key, nKeyLength); + efree(key.u); + return ret; + } else { + return zend_u_hash_exists(ht, IS_STRING, ZSTR(arKey), nKeyLength); + } +} + +ZEND_API int zend_rt_hash_exists(HashTable *ht, char *arKey, uint nKeyLength) +{ + TSRMLS_FETCH(); + + if (UG(unicode)) { + zstr key; + int ret; + UErrorCode status = U_ZERO_ERROR; + int u_len; + + zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &key.u, &u_len, arKey, nKeyLength-1, &status); + if (U_FAILURE(status)) { + ZEND_HASH_CVT_ERROR(); + goto string_key; + } + ret = zend_u_hash_exists(ht, IS_UNICODE, key, u_len+1); + efree(key.u); + return ret; + } else { +string_key: + return zend_u_hash_exists(ht, IS_STRING, ZSTR(arKey), nKeyLength); + } +} + ZEND_API int zend_u_hash_quick_exists(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, ulong h) { uint nIndex; @@ -1726,6 +1894,60 @@ ZEND_API int zend_symtable_update_current_key(HashTable *ht, char *arKey, uint n return zend_hash_update_current_key(ht, HASH_KEY_IS_STRING, ZSTR(arKey), nKeyLength, 0); } +ZEND_API int zend_ascii_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_update(ht, idx, pData, nDataSize, pDest)); + return zend_ascii_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest); +} + + +ZEND_API int zend_ascii_symtable_del(HashTable *ht, char *arKey, uint nKeyLength) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx)) + return zend_ascii_hash_del(ht, arKey, nKeyLength); +} + + +ZEND_API int zend_ascii_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData)); + return zend_ascii_hash_find(ht, arKey, nKeyLength, pData); +} + + +ZEND_API int zend_ascii_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx)); + return zend_ascii_hash_exists(ht, arKey, nKeyLength); +} + +ZEND_API int zend_rt_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_update(ht, idx, pData, nDataSize, pDest)); + return zend_rt_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest); +} + + +ZEND_API int zend_rt_symtable_del(HashTable *ht, char *arKey, uint nKeyLength) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx)) + return zend_rt_hash_del(ht, arKey, nKeyLength); +} + + +ZEND_API int zend_rt_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData)); + return zend_rt_hash_find(ht, arKey, nKeyLength, pData); +} + + +ZEND_API int zend_rt_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength) +{ + HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx)); + return zend_rt_hash_exists(ht, arKey, nKeyLength); +} + ZEND_API void zend_hash_to_unicode(HashTable *ht, apply_func_t apply_func TSRMLS_DC) { Bucket **p; @@ -1747,6 +1969,9 @@ ZEND_API void zend_hash_to_unicode(HashTable *ht, apply_func_t apply_func TSRMLS Bucket *q; zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u, &u_len, (*p)->key.arKey.s, (*p)->nKeyLength-1, &status); + if (U_FAILURE(status)) { + zend_error(E_ERROR, "Cannot convert HashTable to Unicode"); + } q = (Bucket *) pemalloc(sizeof(Bucket)-sizeof(q->key.arKey)+((u_len+1)*2), ht->persistent); memcpy(q, *p, sizeof(Bucket)-sizeof(q->key.arKey)); diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h index 7e3dbd0ba4..b0abd2c305 100644 --- a/Zend/zend_hash.h +++ b/Zend/zend_hash.h @@ -118,13 +118,23 @@ ZEND_API void zend_hash_clean(HashTable *ht); /* additions/updates/changes */ ZEND_API int _zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC); +ZEND_API int _zend_ascii_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC); +ZEND_API int _zend_rt_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC); ZEND_API int _zend_u_hash_add_or_update(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC); #define zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \ _zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC) +#define zend_ascii_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \ + _zend_ascii_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC) +#define zend_rt_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \ + _zend_rt_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC) #define zend_u_hash_update(ht, type, arKey, nKeyLength, pData, nDataSize, pDest) \ _zend_u_hash_add_or_update(ht, type, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC) #define zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \ _zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC) +#define zend_ascii_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \ + _zend_ascii_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC) +#define zend_rt_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \ + _zend_rt_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC) #define zend_u_hash_add(ht, type, arKey, nKeyLength, pData, nDataSize, pDest) \ _zend_u_hash_add_or_update(ht, type, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC) @@ -176,6 +186,8 @@ ZEND_API void zend_hash_to_unicode(HashTable *ht, apply_func_t apply_func TSRMLS /* Deletes */ ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag); +ZEND_API int zend_ascii_hash_del(HashTable *ht, char *arKey, uint nKeyLength); +ZEND_API int zend_rt_hash_del(HashTable *ht, char *arKey, uint nKeyLength); ZEND_API int zend_u_hash_del_key_or_index(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, ulong h, int flag); #define zend_hash_del(ht, arKey, nKeyLength) \ zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0, HASH_DEL_KEY) @@ -189,6 +201,8 @@ ZEND_API ulong zend_u_get_hash_value(zend_uchar type, zstr arKey, uint nKeyLengt /* Data retreival */ ZEND_API int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData); +ZEND_API int zend_ascii_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData); +ZEND_API int zend_rt_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData); ZEND_API int zend_u_hash_find(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, void **pData); ZEND_API int zend_hash_quick_find(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void **pData); ZEND_API int zend_u_hash_quick_find(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, ulong h, void **pData); @@ -196,6 +210,8 @@ ZEND_API int zend_hash_index_find(HashTable *ht, ulong h, void **pData); /* Misc */ ZEND_API int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength); +ZEND_API int zend_ascii_hash_exists(HashTable *ht, char *arKey, uint nKeyLength); +ZEND_API int zend_rt_hash_exists(HashTable *ht, char *arKey, uint nKeyLength); ZEND_API int zend_u_hash_exists(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength); ZEND_API int zend_hash_quick_exists(HashTable *ht, char *arKey, uint nKeyLength, ulong h); ZEND_API int zend_u_hash_quick_exists(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, ulong h); @@ -338,6 +354,16 @@ ZEND_API int zend_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, voi ZEND_API int zend_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength); ZEND_API int zend_symtable_update_current_key(HashTable *ht, char *arKey, uint nKeyLength); +ZEND_API int zend_ascii_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest); +ZEND_API int zend_ascii_symtable_del(HashTable *ht, char *arKey, uint nKeyLength); +ZEND_API int zend_ascii_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData); +ZEND_API int zend_ascii_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength); + +ZEND_API int zend_rt_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest); +ZEND_API int zend_rt_symtable_del(HashTable *ht, char *arKey, uint nKeyLength); +ZEND_API int zend_rt_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData); +ZEND_API int zend_rt_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength); + ZEND_API int zend_u_symtable_update(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest); ZEND_API int zend_u_symtable_del(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength); ZEND_API int zend_u_symtable_find(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, void **pData); diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index f2d4d2c49c..297b3a629a 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -985,7 +985,7 @@ static void convert_scalar_to_array(zval *op, int type TSRMLS_DC) switch (type) { case IS_ARRAY: ALLOC_HASHTABLE(Z_ARRVAL_P(op)); - zend_u_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0, UG(unicode)); + zend_u_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0, 0); zend_hash_index_update(Z_ARRVAL_P(op), 0, (void *) &entry, sizeof(zval *), NULL); Z_TYPE_P(op) = IS_ARRAY; break; @@ -1017,7 +1017,7 @@ ZEND_API void convert_to_array(zval *op) HashTable *ht; ALLOC_HASHTABLE(ht); - zend_u_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0, UG(unicode)); + zend_u_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0, 0); if (Z_OBJ_HT_P(op)->get_properties) { HashTable *obj_ht = Z_OBJ_HT_P(op)->get_properties(op TSRMLS_CC); if(obj_ht) { @@ -1037,7 +1037,7 @@ ZEND_API void convert_to_array(zval *op) return; case IS_NULL: ALLOC_HASHTABLE(Z_ARRVAL_P(op)); - zend_u_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0, UG(unicode)); + zend_u_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0, 0); Z_TYPE_P(op) = IS_ARRAY; break; default: diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 20da38c6ea..01f481da16 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2702,7 +2702,7 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -3074,7 +3074,7 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -3560,7 +3560,7 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST| break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 733596a60c..0755c04ae4 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -66,7 +66,7 @@ ZEND_API void execute(zend_op_array *op_array TSRMLS_DC) if (op_array->uses_this && EG(This)) { EG(This)->refcount++; /* For $this pointer */ - if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) { + if (zend_ascii_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) { EG(This)->refcount--; } } @@ -2725,7 +2725,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -3085,7 +3085,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -3445,7 +3445,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -3539,7 +3539,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -3898,7 +3898,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -5408,7 +5408,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -5856,7 +5856,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -6304,7 +6304,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -6398,7 +6398,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -6843,7 +6843,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -9501,7 +9501,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -9613,7 +9613,7 @@ static int ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -9746,7 +9746,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -11041,7 +11041,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -11153,7 +11153,7 @@ static int ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -11286,7 +11286,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZE break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -12619,7 +12619,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -12731,7 +12731,7 @@ static int ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -12864,7 +12864,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZE break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -13368,7 +13368,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -14627,7 +14627,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -14739,7 +14739,7 @@ static int ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -14872,7 +14872,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEN break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -15882,7 +15882,7 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -16013,7 +16013,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_di break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -16899,7 +16899,7 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -17030,7 +17030,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -17916,7 +17916,7 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -18047,7 +18047,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -19197,7 +19197,7 @@ static int ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -19328,7 +19328,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -21878,7 +21878,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -21990,7 +21990,7 @@ static int ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -22121,7 +22121,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, Z break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -23410,7 +23410,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -23522,7 +23522,7 @@ static int ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -23653,7 +23653,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEN break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -24979,7 +24979,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -25091,7 +25091,7 @@ static int ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -25222,7 +25222,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEN break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; @@ -25723,7 +25723,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -26977,7 +26977,7 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_u_symtable_update(Z_ARRVAL_P(array_ptr), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL); break; case IS_NULL: - zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + zend_u_hash_update(Z_ARRVAL_P(array_ptr), ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), &expr_ptr, sizeof(zval *), NULL); break; default: zend_error(E_WARNING, "Illegal offset type"); @@ -27089,7 +27089,7 @@ static int ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) break; } case IS_NULL: - zend_hash_del(ht, "", sizeof("")); + zend_u_hash_del(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof("")); break; default: zend_error(E_WARNING, "Illegal offset type in unset"); @@ -27220,7 +27220,7 @@ static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND break; } case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { + if (zend_u_hash_find(ht, ZEND_STR_TYPE, EMPTY_ZSTR, sizeof(""), (void **) &value) == SUCCESS) { isset = 1; } break; diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl index 9dd40f9ef9..b7a269d39c 100644 --- a/Zend/zend_vm_execute.skl +++ b/Zend/zend_vm_execute.skl @@ -37,7 +37,7 @@ ZEND_API void {%EXECUTOR_NAME%}(zend_op_array *op_array TSRMLS_DC) if (op_array->uses_this && EG(This)) { EG(This)->refcount++; /* For $this pointer */ - if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) { + if (zend_ascii_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) { EG(This)->refcount--; } } diff --git a/ext/date/php_date.c b/ext/date/php_date.c index 3ecb30fbae..62f4b19bca 100644 --- a/ext/date/php_date.c +++ b/ext/date/php_date.c @@ -1511,15 +1511,15 @@ PHP_FUNCTION(localtime) array_init(return_value); if (associative) { - add_assoc_long(return_value, "tm_sec", ts->s); - add_assoc_long(return_value, "tm_min", ts->i); - add_assoc_long(return_value, "tm_hour", ts->h); - add_assoc_long(return_value, "tm_mday", ts->d); - add_assoc_long(return_value, "tm_mon", ts->m - 1); - add_assoc_long(return_value, "tm_year", ts->y - 1900); - add_assoc_long(return_value, "tm_wday", timelib_day_of_week(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "tm_yday", timelib_day_of_year(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "tm_isdst", ts->dst); + add_ascii_assoc_long(return_value, "tm_sec", ts->s); + add_ascii_assoc_long(return_value, "tm_min", ts->i); + add_ascii_assoc_long(return_value, "tm_hour", ts->h); + add_ascii_assoc_long(return_value, "tm_mday", ts->d); + add_ascii_assoc_long(return_value, "tm_mon", ts->m - 1); + add_ascii_assoc_long(return_value, "tm_year", ts->y - 1900); + add_ascii_assoc_long(return_value, "tm_wday", timelib_day_of_week(ts->y, ts->m, ts->d)); + add_ascii_assoc_long(return_value, "tm_yday", timelib_day_of_year(ts->y, ts->m, ts->d)); + add_ascii_assoc_long(return_value, "tm_isdst", ts->dst); } else { add_next_index_long(return_value, ts->s); add_next_index_long(return_value, ts->i); @@ -1556,16 +1556,16 @@ PHP_FUNCTION(getdate) array_init(return_value); - add_assoc_long(return_value, "seconds", ts->s); - add_assoc_long(return_value, "minutes", ts->i); - add_assoc_long(return_value, "hours", ts->h); - add_assoc_long(return_value, "mday", ts->d); - add_assoc_long(return_value, "wday", timelib_day_of_week(ts->y, ts->m, ts->d)); - add_assoc_long(return_value, "mon", ts->m); - add_assoc_long(return_value, "year", ts->y); - add_assoc_long(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d)); - add_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d), 1); - add_assoc_string(return_value, "month", mon_full_names[ts->m - 1], 1); + add_ascii_assoc_long(return_value, "seconds", ts->s); + add_ascii_assoc_long(return_value, "minutes", ts->i); + add_ascii_assoc_long(return_value, "hours", ts->h); + add_ascii_assoc_long(return_value, "mday", ts->d); + add_ascii_assoc_long(return_value, "wday", timelib_day_of_week(ts->y, ts->m, ts->d)); + add_ascii_assoc_long(return_value, "mon", ts->m); + add_ascii_assoc_long(return_value, "year", ts->y); + add_ascii_assoc_long(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d)); + add_ascii_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d), 1); + add_ascii_assoc_string(return_value, "month", mon_full_names[ts->m - 1], 1); add_index_long(return_value, 0, timestamp); timelib_time_dtor(ts); @@ -1831,9 +1831,9 @@ PHP_FUNCTION(date_parse) array_init(return_value); #define PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(name, elem) \ if (parsed_time->elem == -1) { \ - add_assoc_bool(return_value, #name, 0); \ + add_ascii_assoc_bool(return_value, #name, 0); \ } else { \ - add_assoc_long(return_value, #name, parsed_time->elem); \ + add_ascii_assoc_long(return_value, #name, parsed_time->elem); \ } PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(year, y); PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(month, m); @@ -1843,49 +1843,49 @@ PHP_FUNCTION(date_parse) PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(second, s); if (parsed_time->f == -1) { - add_assoc_bool(return_value, "fraction", 0); + add_ascii_assoc_bool(return_value, "fraction", 0); } else { - add_assoc_double(return_value, "fraction", parsed_time->f); + add_ascii_assoc_double(return_value, "fraction", parsed_time->f); } - add_assoc_long(return_value, "warning_count", error->warning_count); + add_ascii_assoc_long(return_value, "warning_count", error->warning_count); MAKE_STD_ZVAL(element); array_init(element); for (i = 0; i < error->warning_count; i++) { add_index_string(element, error->warning_messages[i].position, error->warning_messages[i].message, 1); } - add_assoc_zval(return_value, "warnings", element); + add_ascii_assoc_zval(return_value, "warnings", element); - add_assoc_long(return_value, "error_count", error->error_count); + add_ascii_assoc_long(return_value, "error_count", error->error_count); MAKE_STD_ZVAL(element); array_init(element); for (i = 0; i < error->error_count; i++) { add_index_string(element, error->error_messages[i].position, error->error_messages[i].message, 1); } - add_assoc_zval(return_value, "errors", element); + add_ascii_assoc_zval(return_value, "errors", element); timelib_error_container_dtor(error); - add_assoc_bool(return_value, "is_localtime", parsed_time->is_localtime); + add_ascii_assoc_bool(return_value, "is_localtime", parsed_time->is_localtime); if (parsed_time->is_localtime) { PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone_type, zone_type); switch (parsed_time->zone_type) { case TIMELIB_ZONETYPE_OFFSET: PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone, z); - add_assoc_bool(return_value, "is_dst", parsed_time->dst); + add_ascii_assoc_bool(return_value, "is_dst", parsed_time->dst); break; case TIMELIB_ZONETYPE_ID: if (parsed_time->tz_abbr) { - add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1); + add_ascii_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1); } if (parsed_time->tz_info) { - add_assoc_string(return_value, "tz_id", parsed_time->tz_info->name, 1); + add_ascii_assoc_string(return_value, "tz_id", parsed_time->tz_info->name, 1); } break; case TIMELIB_ZONETYPE_ABBR: PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone, z); - add_assoc_bool(return_value, "is_dst", parsed_time->dst); - add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1); + add_ascii_assoc_bool(return_value, "is_dst", parsed_time->dst); + add_ascii_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1); break; } } @@ -1894,18 +1894,18 @@ PHP_FUNCTION(date_parse) array_init(element); } if (parsed_time->have_relative) { - add_assoc_long(element, "year", parsed_time->relative.y); - add_assoc_long(element, "month", parsed_time->relative.m); - add_assoc_long(element, "day", parsed_time->relative.d); - add_assoc_long(element, "hour", parsed_time->relative.h); - add_assoc_long(element, "minute", parsed_time->relative.i); - add_assoc_long(element, "second", parsed_time->relative.s); + add_ascii_assoc_long(element, "year", parsed_time->relative.y); + add_ascii_assoc_long(element, "month", parsed_time->relative.m); + add_ascii_assoc_long(element, "day", parsed_time->relative.d); + add_ascii_assoc_long(element, "hour", parsed_time->relative.h); + add_ascii_assoc_long(element, "minute", parsed_time->relative.i); + add_ascii_assoc_long(element, "second", parsed_time->relative.s); } if (parsed_time->have_weekday_relative) { - add_assoc_long(element, "weekday", parsed_time->relative.weekday); + add_ascii_assoc_long(element, "weekday", parsed_time->relative.weekday); } if (parsed_time->have_relative || parsed_time->have_weekday_relative) { - add_assoc_zval(return_value, "relative", element); + add_ascii_assoc_zval(return_value, "relative", element); } timelib_time_dtor(parsed_time); } @@ -2258,11 +2258,11 @@ PHP_FUNCTION(timezone_transitions_get) for (i = 0; i < tzobj->tz->timecnt; ++i) { MAKE_STD_ZVAL(element); array_init(element); - add_assoc_long(element, "ts", tzobj->tz->trans[i]); - add_assoc_string(element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, tzobj->tz->trans[i], 0 TSRMLS_CC), 0); - add_assoc_long(element, "offset", tzobj->tz->type[tzobj->tz->trans_idx[i]].offset); - add_assoc_bool(element, "isdst", tzobj->tz->type[tzobj->tz->trans_idx[i]].isdst); - add_assoc_string(element, "abbr", &tzobj->tz->timezone_abbr[tzobj->tz->type[tzobj->tz->trans_idx[i]].abbr_idx], 1); + add_ascii_assoc_long(element, "ts", tzobj->tz->trans[i]); + add_ascii_assoc_string(element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, tzobj->tz->trans[i], 0 TSRMLS_CC), 0); + add_ascii_assoc_long(element, "offset", tzobj->tz->type[tzobj->tz->trans_idx[i]].offset); + add_ascii_assoc_bool(element, "isdst", tzobj->tz->type[tzobj->tz->trans_idx[i]].isdst); + add_ascii_assoc_string(element, "abbr", &tzobj->tz->timezone_abbr[tzobj->tz->type[tzobj->tz->trans_idx[i]].abbr_idx], 1); add_next_index_zval(return_value, element); } @@ -2303,18 +2303,18 @@ PHP_FUNCTION(timezone_abbreviations_list) do { MAKE_STD_ZVAL(element); array_init(element); - add_assoc_bool(element, "dst", entry->type); - add_assoc_long(element, "offset", entry->gmtoffset); + add_ascii_assoc_bool(element, "dst", entry->type); + add_ascii_assoc_long(element, "offset", entry->gmtoffset); if (entry->full_tz_name) { - add_assoc_string(element, "timezone_id", entry->full_tz_name, 1); + add_ascii_assoc_string(element, "timezone_id", entry->full_tz_name, 1); } else { - add_assoc_null(element, "timezone_id"); + add_ascii_assoc_null(element, "timezone_id"); } if (zend_hash_find(HASH_OF(return_value), entry->name, strlen(entry->name) + 1, (void **) &abbr_array_pp) == FAILURE) { MAKE_STD_ZVAL(abbr_array); array_init(abbr_array); - add_assoc_zval(return_value, entry->name, abbr_array); + add_ascii_assoc_zval(return_value, entry->name, abbr_array); } else { abbr_array = *abbr_array_pp; } @@ -2493,74 +2493,74 @@ PHP_FUNCTION(date_sun_info) rs = timelib_astro_rise_set_altitude(t, latitude, longitude, -35.0/60, 1, &ddummy, &ddummy, &rise, &set, &transit); switch (rs) { case -1: /* always below */ - add_assoc_bool(return_value, "sunrise", 0); - add_assoc_bool(return_value, "sunset", 0); + add_ascii_assoc_bool(return_value, "sunrise", 0); + add_ascii_assoc_bool(return_value, "sunset", 0); break; case 1: /* always above */ - add_assoc_bool(return_value, "sunrise", 1); - add_assoc_bool(return_value, "sunset", 1); + add_ascii_assoc_bool(return_value, "sunrise", 1); + add_ascii_assoc_bool(return_value, "sunset", 1); break; default: t2->sse = rise; - add_assoc_long(return_value, "sunrise", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "sunrise", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "sunset", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "sunset", timelib_date_to_int(t2, &dummy)); } t2->sse = transit; - add_assoc_long(return_value, "transit", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "transit", timelib_date_to_int(t2, &dummy)); /* Get civil twilight */ rs = timelib_astro_rise_set_altitude(t, latitude, longitude, -6.0, 0, &ddummy, &ddummy, &rise, &set, &transit); switch (rs) { case -1: /* always below */ - add_assoc_bool(return_value, "civil_twilight_begin", 0); - add_assoc_bool(return_value, "civil_twilight_end", 0); + add_ascii_assoc_bool(return_value, "civil_twilight_begin", 0); + add_ascii_assoc_bool(return_value, "civil_twilight_end", 0); break; case 1: /* always above */ - add_assoc_bool(return_value, "civil_twilight_begin", 1); - add_assoc_bool(return_value, "civil_twilight_end", 1); + add_ascii_assoc_bool(return_value, "civil_twilight_begin", 1); + add_ascii_assoc_bool(return_value, "civil_twilight_end", 1); break; default: t2->sse = rise; - add_assoc_long(return_value, "civil_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "civil_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "civil_twilight_end", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "civil_twilight_end", timelib_date_to_int(t2, &dummy)); } /* Get nautical twilight */ rs = timelib_astro_rise_set_altitude(t, latitude, longitude, -12.0, 0, &ddummy, &ddummy, &rise, &set, &transit); switch (rs) { case -1: /* always below */ - add_assoc_bool(return_value, "nautical_twilight_begin", 0); - add_assoc_bool(return_value, "nautical_twilight_end", 0); + add_ascii_assoc_bool(return_value, "nautical_twilight_begin", 0); + add_ascii_assoc_bool(return_value, "nautical_twilight_end", 0); break; case 1: /* always above */ - add_assoc_bool(return_value, "nautical_twilight_begin", 1); - add_assoc_bool(return_value, "nautical_twilight_end", 1); + add_ascii_assoc_bool(return_value, "nautical_twilight_begin", 1); + add_ascii_assoc_bool(return_value, "nautical_twilight_end", 1); break; default: t2->sse = rise; - add_assoc_long(return_value, "nautical_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "nautical_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "nautical_twilight_end", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "nautical_twilight_end", timelib_date_to_int(t2, &dummy)); } /* Get astronomical twilight */ rs = timelib_astro_rise_set_altitude(t, latitude, longitude, -18.0, 0, &ddummy, &ddummy, &rise, &set, &transit); switch (rs) { case -1: /* always below */ - add_assoc_bool(return_value, "astronomical_twilight_begin", 0); - add_assoc_bool(return_value, "astronomical_twilight_end", 0); + add_ascii_assoc_bool(return_value, "astronomical_twilight_begin", 0); + add_ascii_assoc_bool(return_value, "astronomical_twilight_end", 0); break; case 1: /* always above */ - add_assoc_bool(return_value, "astronomical_twilight_begin", 1); - add_assoc_bool(return_value, "astronomical_twilight_end", 1); + add_ascii_assoc_bool(return_value, "astronomical_twilight_begin", 1); + add_ascii_assoc_bool(return_value, "astronomical_twilight_end", 1); break; default: t2->sse = rise; - add_assoc_long(return_value, "astronomical_twilight_begin", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "astronomical_twilight_begin", timelib_date_to_int(t2, &dummy)); t2->sse = set; - add_assoc_long(return_value, "astronomical_twilight_end", timelib_date_to_int(t2, &dummy)); + add_ascii_assoc_long(return_value, "astronomical_twilight_end", timelib_date_to_int(t2, &dummy)); } timelib_time_dtor(t); timelib_time_dtor(t2); diff --git a/ext/dom/node.c b/ext/dom/node.c index 67ac970498..5bc3cf71f0 100644 --- a/ext/dom/node.c +++ b/ext/dom/node.c @@ -1747,7 +1747,7 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) char *xquery; int xquery_len; - if (zend_hash_find(ht, "query", sizeof("query"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "query", sizeof("query"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { zxquery = tmp; /* @@ -1768,7 +1768,7 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) ctxp = xmlXPathNewContext(docp); ctxp->node = nodep; - if (zend_hash_find(ht, "namespaces", sizeof("namespaces"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "namespaces", sizeof("namespaces"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_ARRAY) { zval **tmpns; char *nschar; diff --git a/ext/filter/logical_filters.c b/ext/filter/logical_filters.c index e3f85f95b2..760f980626 100644 --- a/ext/filter/logical_filters.c +++ b/ext/filter/logical_filters.c @@ -29,7 +29,7 @@ var_name = 0; \ var_name##_set = 0; \ if (option_array) { \ - if (zend_hash_find(HASH_OF(option_array), option_name, sizeof(option_name), (void **) &option_val) == SUCCESS) { \ + if (zend_ascii_hash_find(HASH_OF(option_array), option_name, sizeof(option_name), (void **) &option_val) == SUCCESS) { \ convert_to_long(*option_val); \ var_name = Z_LVAL_PP(option_val); \ var_name##_set = 1; \ @@ -43,7 +43,7 @@ var_name##_set = 0; \ var_name##_len = 0; \ if (option_array) { \ - if (zend_hash_find(HASH_OF(option_array), option_name, sizeof(option_name), (void **) &option_val) == SUCCESS) { \ + if (zend_ascii_hash_find(HASH_OF(option_array), option_name, sizeof(option_name), (void **) &option_val) == SUCCESS) { \ convert_to_string(*option_val); \ var_name = Z_STRVAL_PP(option_val); \ var_name##_set = 1; \ diff --git a/ext/session/session.c b/ext/session/session.c index 396b9cb307..a6a7e90431 100644 --- a/ext/session/session.c +++ b/ext/session/session.c @@ -297,7 +297,7 @@ PHPAPI void php_add_session_var(char *name, size_t namelen TSRMLS_DC) zval **sym_track = NULL; IF_SESSION_VARS() { - zend_hash_find(Z_ARRVAL_P(PS(http_session_vars)), name, namelen + 1, + zend_rt_hash_find(Z_ARRVAL_P(PS(http_session_vars)), name, namelen + 1, (void *) &sym_track); } else { return; @@ -321,7 +321,7 @@ PHPAPI int php_get_session_var(char *name, size_t namelen, zval ***state_var TSR int ret = FAILURE; IF_SESSION_VARS() { - ret = zend_hash_find(Z_ARRVAL_P(PS(http_session_vars)), name, + ret = zend_rt_hash_find(Z_ARRVAL_P(PS(http_session_vars)), name, namelen+1, (void **) state_var); } @@ -591,10 +591,10 @@ PHPAPI char *php_session_create_id(PS_CREATE_SID_ARGS) gettimeofday(&tv, NULL); - if (zend_hash_find(&EG(symbol_table), "_SERVER", + if (zend_ascii_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &array) == SUCCESS && Z_TYPE_PP(array) == IS_ARRAY && - zend_hash_find(Z_ARRVAL_PP(array), "REMOTE_ADDR", + zend_ascii_hash_find(Z_ARRVAL_PP(array), "REMOTE_ADDR", sizeof("REMOTE_ADDR"), (void **) &token) == SUCCESS) { remote_addr = Z_STRVAL_PP(token); } @@ -1027,7 +1027,7 @@ static void php_session_reset_id(TSRMLS_D) } /* if the SID constant exists, destroy it. */ - zend_hash_del(EG(zend_constants), "sid", sizeof("sid")); + zend_ascii_hash_del(EG(zend_constants), "sid", sizeof("sid")); if (PS(define_sid)) { smart_str var = {0}; @@ -1088,10 +1088,10 @@ PHPAPI void php_session_start(TSRMLS_D) */ if (!PS(id)) { - if (PS(use_cookies) && zend_hash_find(&EG(symbol_table), "_COOKIE", + if (PS(use_cookies) && zend_ascii_hash_find(&EG(symbol_table), "_COOKIE", sizeof("_COOKIE"), (void **) &data) == SUCCESS && Z_TYPE_PP(data) == IS_ARRAY && - zend_hash_find(Z_ARRVAL_PP(data), PS(session_name), + zend_ascii_hash_find(Z_ARRVAL_PP(data), PS(session_name), lensess + 1, (void **) &ppid) == SUCCESS) { PPID2SID; PS(apply_trans_sid) = 0; @@ -1100,20 +1100,20 @@ PHPAPI void php_session_start(TSRMLS_D) } if (!PS(use_only_cookies) && !PS(id) && - zend_hash_find(&EG(symbol_table), "_GET", + zend_ascii_hash_find(&EG(symbol_table), "_GET", sizeof("_GET"), (void **) &data) == SUCCESS && Z_TYPE_PP(data) == IS_ARRAY && - zend_hash_find(Z_ARRVAL_PP(data), PS(session_name), + zend_rt_hash_find(Z_ARRVAL_PP(data), PS(session_name), lensess + 1, (void **) &ppid) == SUCCESS) { PPID2SID; PS(send_cookie) = 0; } if (!PS(use_only_cookies) && !PS(id) && - zend_hash_find(&EG(symbol_table), "_POST", + zend_ascii_hash_find(&EG(symbol_table), "_POST", sizeof("_POST"), (void **) &data) == SUCCESS && Z_TYPE_PP(data) == IS_ARRAY && - zend_hash_find(Z_ARRVAL_PP(data), PS(session_name), + zend_rt_hash_find(Z_ARRVAL_PP(data), PS(session_name), lensess + 1, (void **) &ppid) == SUCCESS) { PPID2SID; PS(send_cookie) = 0; @@ -1125,7 +1125,7 @@ PHPAPI void php_session_start(TSRMLS_D) http://yoursite/=/script.php */ if (!PS(use_only_cookies) && !PS(id) && PG(http_globals)[TRACK_VARS_SERVER] && - zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "REQUEST_URI", + zend_ascii_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "REQUEST_URI", sizeof("REQUEST_URI"), (void **) &data) == SUCCESS && Z_TYPE_PP(data) == IS_STRING && (p = strstr(Z_STRVAL_PP(data), PS(session_name))) && @@ -1250,11 +1250,11 @@ PHP_FUNCTION(session_get_cookie_params) array_init(return_value); - add_assoc_long(return_value, "lifetime", PS(cookie_lifetime)); - add_assoc_string(return_value, "path", PS(cookie_path), 1); - add_assoc_string(return_value, "domain", PS(cookie_domain), 1); - add_assoc_bool(return_value, "secure", PS(cookie_secure)); - add_assoc_bool(return_value, "httponly", PS(cookie_httponly)); + add_ascii_assoc_long(return_value, "lifetime", PS(cookie_lifetime)); + add_ascii_assoc_rt_string(return_value, "path", PS(cookie_path), 1); + add_ascii_assoc_rt_string(return_value, "domain", PS(cookie_domain), 1); + add_ascii_assoc_bool(return_value, "secure", PS(cookie_secure)); + add_ascii_assoc_bool(return_value, "httponly", PS(cookie_httponly)); } /* }}} */ diff --git a/ext/simplexml/simplexml.c b/ext/simplexml/simplexml.c index 9e460da568..85b39a7fbc 100644 --- a/ext/simplexml/simplexml.c +++ b/ext/simplexml/simplexml.c @@ -996,7 +996,16 @@ static HashTable * sxe_properties_get(zval *object TSRMLS_DC) array_init(zattr); sxe_properties_add(rv, "@attributes", sizeof("@attributes"), zattr TSRMLS_CC); } - add_assoc_zval_ex(zattr, (char*)attr->name, namelen, value); + if (UG(unicode)) { + UErrorCode status = U_ZERO_ERROR; + zstr u_name; + int u_name_len; + zend_string_to_unicode_ex(UG(utf8_conv), &u_name.u, &u_name_len, (char*)attr->name, namelen, &status); + add_u_assoc_zval_ex(zattr, IS_UNICODE, u_name, u_name_len, value); + efree(u_name.u); + } else { + add_assoc_zval_ex(zattr, (char*)attr->name, namelen, value); + } } attr = attr->next; } @@ -1288,14 +1297,17 @@ static inline void sxe_add_namespace_name(zval *return_value, xmlNsPtr ns TSRMLS prefix_len = strlen(prefix) + 1; - if (zend_hash_exists(Z_ARRVAL_P(return_value), prefix, prefix_len) == 0) { + if (zend_ascii_hash_exists(Z_ARRVAL_P(return_value), prefix, prefix_len) == 0) { if (UG(unicode)) { UErrorCode status = U_ZERO_ERROR; UChar *u_str; - int u_len; + zstr u_prefix; + int u_len, u_prefix_len; int length = strlen((char*)ns->href); zend_string_to_unicode_ex(UG(utf8_conv), &u_str, &u_len, (char*)ns->href, length, &status); - add_assoc_unicodel_ex(return_value, prefix, prefix_len, u_str, u_len, 0); + zend_string_to_unicode_ex(UG(utf8_conv), &u_prefix.u, &u_prefix_len, prefix, prefix_len, &status); + add_u_assoc_unicodel_ex(return_value, IS_UNICODE, u_prefix, u_prefix_len, u_str, u_len, 0); + efree(u_prefix.u); } else { add_assoc_string_ex(return_value, prefix, prefix_len, (char*)ns->href, 1); } diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c index 91bf447384..4b5c90b985 100644 --- a/ext/soap/php_encoding.c +++ b/ext/soap/php_encoding.c @@ -1018,7 +1018,7 @@ static zval* get_zval_property(zval* object, char* name TSRMLS_DC) } else if (Z_TYPE_P(object) == IS_ARRAY) { zval **data_ptr; - if (zend_hash_find(Z_ARRVAL_P(object), name, strlen(name)+1, (void**)&data_ptr) == SUCCESS) { + if (zend_rt_hash_find(Z_ARRVAL_P(object), name, strlen(name)+1, (void**)&data_ptr) == SUCCESS) { return *data_ptr; } } diff --git a/ext/soap/php_packet_soap.c b/ext/soap/php_packet_soap.c index 20cc1b8913..b688964cf1 100644 --- a/ext/soap/php_packet_soap.c +++ b/ext/soap/php_packet_soap.c @@ -318,7 +318,16 @@ int parse_packet_soap(zval *this_ptr, char *buffer, int buffer_size, sdlFunction tmp = master_to_zval(NULL, val); } } - add_assoc_zval(return_value, param->paramName, tmp); + if (UG(unicode)) { + UErrorCode status = U_ZERO_ERROR; + zstr u_name; + int u_name_len; + zend_string_to_unicode_ex(UG(utf8_conv), &u_name.u, &u_name_len, param->paramName, strlen(param->paramName), &status); + add_u_assoc_zval_ex(return_value, IS_UNICODE, u_name, u_name_len+1, tmp); + efree(u_name.u); + } else { + add_assoc_zval(return_value, param->paramName, tmp); + } param_count++; @@ -339,7 +348,16 @@ int parse_packet_soap(zval *this_ptr, char *buffer, int buffer_size, sdlFunction tmp = master_to_zval(NULL, val); if (val->name) { - add_assoc_zval(return_value, (char*)val->name, tmp); + if (UG(unicode)) { + UErrorCode status = U_ZERO_ERROR; + zstr u_name; + int u_name_len; + zend_string_to_unicode_ex(UG(utf8_conv), &u_name.u, &u_name_len, (char*)val->name, strlen((char*)val->name), &status); + add_u_assoc_zval_ex(return_value, IS_UNICODE, u_name, u_name_len+1, tmp); + efree(u_name.u); + } else { + add_assoc_zval(return_value, (char*)val->name, tmp); + } } else { add_next_index_zval(return_value, tmp); } @@ -391,7 +409,16 @@ int parse_packet_soap(zval *this_ptr, char *buffer, int buffer_size, sdlFunction smart_str_free(&key); } val = master_to_zval(enc, trav); - add_assoc_zval(soap_headers, (char*)trav->name, val); + if (UG(unicode)) { + UErrorCode status = U_ZERO_ERROR; + zstr u_name; + int u_name_len; + zend_string_to_unicode_ex(UG(utf8_conv), &u_name.u, &u_name_len, (char*)trav->name, strlen((char*)trav->name), &status); + add_u_assoc_zval_ex(soap_headers, IS_UNICODE, u_name, u_name_len+1, val); + efree(u_name.u); + } else { + add_assoc_zval(soap_headers, (char*)trav->name, val); + } } trav = trav->next; } diff --git a/ext/soap/soap.c b/ext/soap/soap.c index 91d3a07181..f5bf40ca83 100644 --- a/ext/soap/soap.c +++ b/ext/soap/soap.c @@ -1236,14 +1236,14 @@ PHP_METHOD(SoapServer, SoapServer) HashTable *ht = Z_ARRVAL_P(options); zval **tmp; - if (zend_hash_find(ht, "soap_version", sizeof("soap_version"), (void**)&tmp) == SUCCESS) { + if (zend_ascii_hash_find(ht, "soap_version", sizeof("soap_version"), (void**)&tmp) == SUCCESS) { if (Z_TYPE_PP(tmp) == IS_LONG || (Z_LVAL_PP(tmp) == SOAP_1_1 && Z_LVAL_PP(tmp) == SOAP_1_2)) { version = Z_LVAL_PP(tmp); } } - if (zend_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS) { + if (zend_ascii_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS) { if (Z_TYPE_PP(tmp) == IS_STRING) { service->uri = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); } else if (Z_TYPE_PP(tmp) == IS_UNICODE) { @@ -1251,7 +1251,7 @@ PHP_METHOD(SoapServer, SoapServer) } } - if (zend_hash_find(ht, "actor", sizeof("actor"), (void**)&tmp) == SUCCESS) { + if (zend_ascii_hash_find(ht, "actor", sizeof("actor"), (void**)&tmp) == SUCCESS) { if (Z_TYPE_PP(tmp) == IS_STRING) { service->actor = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); } else if (Z_TYPE_PP(tmp) == IS_UNICODE) { @@ -1259,7 +1259,7 @@ PHP_METHOD(SoapServer, SoapServer) } } - if (zend_hash_find(ht, "encoding", sizeof("encoding"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "encoding", sizeof("encoding"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { xmlCharEncodingHandlerPtr encoding; char *str; @@ -1280,7 +1280,7 @@ PHP_METHOD(SoapServer, SoapServer) } } - if (zend_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_ARRAY) { zval *ztmp; @@ -1289,12 +1289,12 @@ PHP_METHOD(SoapServer, SoapServer) zend_hash_copy(service->class_map, (*tmp)->value.ht, (copy_ctor_func_t) zval_add_ref, (void *) &ztmp, sizeof(zval *)); } - if (zend_hash_find(ht, "features", sizeof("features"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "features", sizeof("features"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) { service->features = Z_LVAL_PP(tmp); } - if (zend_hash_find(ht, "cache_wsdl", sizeof("cache_wsdl"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "cache_wsdl", sizeof("cache_wsdl"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) { cache_wsdl = Z_LVAL_PP(tmp); } @@ -1777,16 +1777,16 @@ PHP_METHOD(SoapServer, handle) } if (ZEND_NUM_ARGS() == 0) { - if (zend_hash_find(&EG(symbol_table), HTTP_RAW_POST_DATA, sizeof(HTTP_RAW_POST_DATA), (void **) &raw_post) != FAILURE && + if (zend_ascii_hash_find(&EG(symbol_table), HTTP_RAW_POST_DATA, sizeof(HTTP_RAW_POST_DATA), (void **) &raw_post) != FAILURE && (Z_TYPE_PP(raw_post) == IS_STRING || Z_TYPE_PP(raw_post) == IS_UNICODE)) { if (Z_TYPE_PP(raw_post) == IS_STRING) { zval **server_vars, **encoding; zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC); - if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &server_vars) == SUCCESS && + if (zend_ascii_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &server_vars) == SUCCESS && Z_TYPE_PP(server_vars) == IS_ARRAY && - zend_hash_find(Z_ARRVAL_PP(server_vars), "HTTP_CONTENT_ENCODING", sizeof("HTTP_CONTENT_ENCODING"), (void **) &encoding)==SUCCESS && + zend_ascii_hash_find(Z_ARRVAL_PP(server_vars), "HTTP_CONTENT_ENCODING", sizeof("HTTP_CONTENT_ENCODING"), (void **) &encoding)==SUCCESS && (Z_TYPE_PP(encoding) == IS_STRING || Z_TYPE_PP(encoding) == IS_UNICODE)) { zval func; zval retval; @@ -1892,7 +1892,7 @@ PHP_METHOD(SoapServer, handle) } /* Find the soap object and assign */ - if (zend_hash_find(Z_ARRVAL_P(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name"), (void **) &tmp_soap) == SUCCESS && + if (zend_ascii_hash_find(Z_ARRVAL_P(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name"), (void **) &tmp_soap) == SUCCESS && Z_TYPE_PP(tmp_soap) == IS_OBJECT && Z_OBJCE_PP(tmp_soap) == service->soap_class.ce) { soap_obj = *tmp_soap; @@ -1968,7 +1968,7 @@ PHP_METHOD(SoapServer, handle) /* If session then update session hash with new object */ if (service->soap_class.persistance == SOAP_PERSISTENCE_SESSION) { zval **tmp_soap_pp; - if (zend_hash_update(Z_ARRVAL_P(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name"), &tmp_soap, sizeof(zval *), (void **)&tmp_soap_pp) == SUCCESS) { + if (zend_ascii_hash_update(Z_ARRVAL_P(PS(http_session_vars)), "_bogus_session_name", sizeof("_bogus_session_name"), &tmp_soap, sizeof(zval *), (void **)&tmp_soap_pp) == SUCCESS) { soap_obj = *tmp_soap_pp; } } else { @@ -2534,7 +2534,7 @@ PHP_METHOD(SoapClient, SoapClient) if (wsdl == NULL) { /* Fetching non-WSDL mode options */ - if (zend_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->uri = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); @@ -2546,25 +2546,25 @@ PHP_METHOD(SoapClient, SoapClient) return; } - if (zend_hash_find(ht, "style", sizeof("style"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "style", sizeof("style"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG && (Z_LVAL_PP(tmp) == SOAP_RPC || Z_LVAL_PP(tmp) == SOAP_DOCUMENT)) { client->style = Z_LVAL_PP(tmp); } - if (zend_hash_find(ht, "use", sizeof("use"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "use", sizeof("use"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG && (Z_LVAL_PP(tmp) == SOAP_LITERAL || Z_LVAL_PP(tmp) == SOAP_ENCODED)) { client->use = Z_LVAL_PP(tmp); } } - if (zend_hash_find(ht, "stream_context", sizeof("stream_context"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "stream_context", sizeof("stream_context"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_RESOURCE) { context = php_stream_context_from_zval(*tmp, 1); } - if (zend_hash_find(ht, "location", sizeof("location"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "location", sizeof("location"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->location = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); @@ -2576,20 +2576,20 @@ PHP_METHOD(SoapClient, SoapClient) return; } - if (zend_hash_find(ht, "soap_version", sizeof("soap_version"), (void**)&tmp) == SUCCESS) { + if (zend_ascii_hash_find(ht, "soap_version", sizeof("soap_version"), (void**)&tmp) == SUCCESS) { if (Z_TYPE_PP(tmp) == IS_LONG || (Z_LVAL_PP(tmp) == SOAP_1_1 && Z_LVAL_PP(tmp) == SOAP_1_2)) { soap_version = Z_LVAL_PP(tmp); } } - if (zend_hash_find(ht, "login", sizeof("login"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "login", sizeof("login"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->login = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); } else { client->login = soap_unicode_to_string(Z_USTRVAL_PP(tmp), Z_USTRLEN_PP(tmp) TSRMLS_CC); } - if (zend_hash_find(ht, "password", sizeof("password"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "password", sizeof("password"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->password = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); @@ -2597,31 +2597,31 @@ PHP_METHOD(SoapClient, SoapClient) client->password = soap_unicode_to_string(Z_USTRVAL_PP(tmp), Z_USTRLEN_PP(tmp) TSRMLS_CC); } } - if (zend_hash_find(ht, "authentication", sizeof("authentication"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "authentication", sizeof("authentication"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG && Z_LVAL_PP(tmp) == SOAP_AUTHENTICATION_DIGEST) { client->digest = 1; } } - if (zend_hash_find(ht, "proxy_host", sizeof("proxy_host"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "proxy_host", sizeof("proxy_host"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->proxy_host = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); } else { client->proxy_host = soap_unicode_to_string(Z_USTRVAL_PP(tmp), Z_USTRLEN_PP(tmp) TSRMLS_CC); } - if (zend_hash_find(ht, "proxy_port", sizeof("proxy_port"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "proxy_port", sizeof("proxy_port"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) { client->proxy_port = Z_LVAL_PP(tmp); } - if (zend_hash_find(ht, "proxy_login", sizeof("proxy_login"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "proxy_login", sizeof("proxy_login"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->proxy_login = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); } else { client->proxy_login = soap_unicode_to_string(Z_USTRVAL_PP(tmp), Z_USTRLEN_PP(tmp) TSRMLS_CC); } - if (zend_hash_find(ht, "proxy_password", sizeof("proxy_password"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "proxy_password", sizeof("proxy_password"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->proxy_password = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); @@ -2631,28 +2631,28 @@ PHP_METHOD(SoapClient, SoapClient) } } } - if (zend_hash_find(ht, "local_cert", sizeof("local_cert"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "local_cert", sizeof("local_cert"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING) { if (!context) { context = php_stream_context_alloc(); } php_stream_context_set_option(context, "ssl", "local_cert", *tmp); - if (zend_hash_find(ht, "passphrase", sizeof("passphrase"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "passphrase", sizeof("passphrase"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_STRING) { php_stream_context_set_option(context, "ssl", "passphrase", *tmp); } } - if (zend_hash_find(ht, "trace", sizeof("trace"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "trace", sizeof("trace"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_BOOL || Z_TYPE_PP(tmp) == IS_LONG) && Z_LVAL_PP(tmp) == 1) { client->trace = 1; } - if (zend_hash_find(ht, "exceptions", sizeof("exceptions"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "exceptions", sizeof("exceptions"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_BOOL || Z_TYPE_PP(tmp) == IS_LONG) && Z_LVAL_PP(tmp) == 0) { client->exceptions = 0; } - if (zend_hash_find(ht, "compression", sizeof("compression"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "compression", sizeof("compression"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG && zend_hash_exists(EG(function_table), "gzinflate", sizeof("gzinflate")) && zend_hash_exists(EG(function_table), "gzdeflate", sizeof("gzdeflate")) && @@ -2661,7 +2661,7 @@ PHP_METHOD(SoapClient, SoapClient) zend_hash_exists(EG(function_table), "gzencode", sizeof("gzencode"))) { client->compression = Z_LVAL_PP(tmp); } - if (zend_hash_find(ht, "encoding", sizeof("encoding"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "encoding", sizeof("encoding"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { xmlCharEncodingHandlerPtr encoding; char *str; @@ -2681,7 +2681,7 @@ PHP_METHOD(SoapClient, SoapClient) efree(str); } } - if (zend_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_ARRAY) { zval *ztmp; @@ -2690,12 +2690,12 @@ PHP_METHOD(SoapClient, SoapClient) zend_hash_copy(client->class_map, (*tmp)->value.ht, (copy_ctor_func_t) zval_add_ref, (void *) &ztmp, sizeof(zval *)); } - if (zend_hash_find(ht, "features", sizeof("features"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "features", sizeof("features"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) { client->features = Z_LVAL_PP(tmp); } - if (zend_hash_find(ht, "connection_timeout", sizeof("connection_timeout"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "connection_timeout", sizeof("connection_timeout"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG && Z_LVAL_PP(tmp) >= 0) { client->connection_timeout = Z_LVAL_PP(tmp); } @@ -2704,12 +2704,12 @@ PHP_METHOD(SoapClient, SoapClient) client->stream_context = context; } - if (zend_hash_find(ht, "cache_wsdl", sizeof("cache_wsdl"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "cache_wsdl", sizeof("cache_wsdl"), (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) { cache_wsdl = Z_LVAL_PP(tmp); } - if (zend_hash_find(ht, "user_agent", sizeof("user_agent"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "user_agent", sizeof("user_agent"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { client->user_agent = estrndup(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); @@ -3053,7 +3053,7 @@ PHP_METHOD(SoapClient, __call) if (options) { if (Z_TYPE_P(options) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(options); - if (zend_hash_find(ht, "location", sizeof("location"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "location", sizeof("location"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { location = Z_STRVAL_PP(tmp); @@ -3063,7 +3063,7 @@ PHP_METHOD(SoapClient, __call) } } - if (zend_hash_find(ht, "soapaction", sizeof("soapaction"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "soapaction", sizeof("soapaction"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { soap_action = Z_STRVAL_PP(tmp); @@ -3073,7 +3073,7 @@ PHP_METHOD(SoapClient, __call) } } - if (zend_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS && + if (zend_ascii_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS && (Z_TYPE_PP(tmp) == IS_STRING || Z_TYPE_PP(tmp) == IS_UNICODE)) { if (Z_TYPE_PP(tmp) == IS_STRING) { uri = Z_STRVAL_PP(tmp); diff --git a/ext/sqlite/sqlite.c b/ext/sqlite/sqlite.c index 812e8f08ea..64ea9dcd09 100644 --- a/ext/sqlite/sqlite.c +++ b/ext/sqlite/sqlite.c @@ -1702,7 +1702,7 @@ PHP_FUNCTION(sqlite_fetch_column_types) zend_string_to_unicode_ex(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &u_str, &u_len, tmp, strlen(tmp), &status); if (result_type == PHPSQLITE_ASSOC) { - add_assoc_unicode(return_value, colname, u_str, 1); + add_rt_assoc_unicode(return_value, colname, u_str, 1); } if (result_type == PHPSQLITE_NUM) { add_index_unicode(return_value, i, u_str, 1); @@ -1885,12 +1885,12 @@ static void php_sqlite_fetch_array(struct php_sqlite_result *res, int mode, zend if (mode & PHPSQLITE_ASSOC) { add_index_zval(return_value, j, decoded); ZVAL_ADDREF(decoded); - add_assoc_zval(return_value, (char*)colnames[j], decoded); + add_rt_assoc_zval(return_value, (char*)colnames[j], decoded); } else { add_next_index_zval(return_value, decoded); } } else { - add_assoc_zval(return_value, (char*)colnames[j], decoded); + add_rt_assoc_zval(return_value, (char*)colnames[j], decoded); } } diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index f9782bf0a9..5463289149 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -4484,8 +4484,8 @@ PHP_FUNCTION(getopt) * in order to be on the safe side, even though it is also available * from the symbol table. */ - if (zend_hash_find(HASH_OF(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), (void **) &args) != FAILURE || - zend_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void **) &args) != FAILURE) { + if (zend_ascii_hash_find(HASH_OF(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), (void **) &args) != FAILURE || + zend_ascii_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void **) &args) != FAILURE) { int pos = 0; zval **arg; @@ -4702,8 +4702,8 @@ PHP_FUNCTION(time_nanosleep) RETURN_TRUE; } else if (errno == EINTR) { array_init(return_value); - add_assoc_long_ex(return_value, "seconds", sizeof("seconds"), php_rem.tv_sec); - add_assoc_long_ex(return_value, "nanoseconds", sizeof("nanoseconds"), php_rem.tv_nsec); + add_ascii_assoc_long_ex(return_value, "seconds", sizeof("seconds"), php_rem.tv_sec); + add_ascii_assoc_long_ex(return_value, "nanoseconds", sizeof("nanoseconds"), php_rem.tv_nsec); return; } else if (errno == EINVAL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "nanoseconds was not in the range 0 to 999 999 999 or seconds was negative"); @@ -4967,10 +4967,10 @@ PHP_FUNCTION(error_get_last) } if (PG(last_error_message)) { array_init(return_value); - add_assoc_long_ex(return_value, "type", sizeof("type"), PG(last_error_type)); - add_assoc_string_ex(return_value, "message", sizeof("message"), PG(last_error_message), 1); - add_assoc_string_ex(return_value, "file", sizeof("file"), PG(last_error_file)?PG(last_error_file):"-", 1 ); - add_assoc_long_ex(return_value, "line", sizeof("line"), PG(last_error_lineno)); + add_ascii_assoc_long_ex(return_value, "type", sizeof("type"), PG(last_error_type)); + add_ascii_assoc_string_ex(return_value, "message", sizeof("message"), PG(last_error_message), 1); + add_ascii_assoc_string_ex(return_value, "file", sizeof("file"), PG(last_error_file)?PG(last_error_file):"-", 1 ); + add_ascii_assoc_long_ex(return_value, "line", sizeof("line"), PG(last_error_lineno)); } } /* }}} */ @@ -5521,22 +5521,22 @@ static int php_ini_get_option(zend_ini_entry *ini_entry, int num_args, va_list a array_init(option); if (ini_entry->orig_value) { - add_assoc_stringl(option, "global_value", ini_entry->orig_value, ini_entry->orig_value_length, 1); + add_ascii_assoc_stringl(option, "global_value", ini_entry->orig_value, ini_entry->orig_value_length, 1); } else if (ini_entry->value) { - add_assoc_stringl(option, "global_value", ini_entry->value, ini_entry->value_length, 1); + add_ascii_assoc_stringl(option, "global_value", ini_entry->value, ini_entry->value_length, 1); } else { - add_assoc_null(option, "global_value"); + add_ascii_assoc_null(option, "global_value"); } if (ini_entry->value) { - add_assoc_stringl(option, "local_value", ini_entry->value, ini_entry->value_length, 1); + add_ascii_assoc_stringl(option, "local_value", ini_entry->value, ini_entry->value_length, 1); } else { - add_assoc_null(option, "local_value"); + add_ascii_assoc_null(option, "local_value"); } - add_assoc_long(option, "access", ini_entry->modifiable); + add_ascii_assoc_long(option, "access", ini_entry->modifiable); - add_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, option); + add_ascii_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, option); } return 0; } diff --git a/ext/standard/datetime.c b/ext/standard/datetime.c index ddb7249b35..80416362c3 100644 --- a/ext/standard/datetime.c +++ b/ext/standard/datetime.c @@ -109,15 +109,15 @@ PHP_FUNCTION(strptime) } array_init(return_value); - add_assoc_long(return_value, "tm_sec", parsed_time.tm_sec); - add_assoc_long(return_value, "tm_min", parsed_time.tm_min); - add_assoc_long(return_value, "tm_hour", parsed_time.tm_hour); - add_assoc_long(return_value, "tm_mday", parsed_time.tm_mday); - add_assoc_long(return_value, "tm_mon", parsed_time.tm_mon); - add_assoc_long(return_value, "tm_year", parsed_time.tm_year); - add_assoc_long(return_value, "tm_wday", parsed_time.tm_wday); - add_assoc_long(return_value, "tm_yday", parsed_time.tm_yday); - add_assoc_string(return_value, "unparsed", unparsed_part, 1); + add_ascii_assoc_long(return_value, "tm_sec", parsed_time.tm_sec); + add_ascii_assoc_long(return_value, "tm_min", parsed_time.tm_min); + add_ascii_assoc_long(return_value, "tm_hour", parsed_time.tm_hour); + add_ascii_assoc_long(return_value, "tm_mday", parsed_time.tm_mday); + add_ascii_assoc_long(return_value, "tm_mon", parsed_time.tm_mon); + add_ascii_assoc_long(return_value, "tm_year", parsed_time.tm_year); + add_ascii_assoc_long(return_value, "tm_wday", parsed_time.tm_wday); + add_ascii_assoc_long(return_value, "tm_yday", parsed_time.tm_yday); + add_ascii_assoc_string(return_value, "unparsed", unparsed_part, 1); } /* }}} */ #endif diff --git a/ext/standard/dns.c b/ext/standard/dns.c index 8497296486..2bed0eb5fc 100644 --- a/ext/standard/dns.c +++ b/ext/standard/dns.c @@ -426,82 +426,82 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int ALLOC_INIT_ZVAL(*subarray); array_init(*subarray); - add_assoc_string(*subarray, "host", name, 1); + add_ascii_assoc_string(*subarray, "host", name, 1); switch (type) { case DNS_T_A: - add_assoc_string(*subarray, "type", "A", 1); + add_ascii_assoc_string(*subarray, "type", "A", 1); sprintf(name, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]); - add_assoc_string(*subarray, "ip", name, 1); + add_ascii_assoc_string(*subarray, "ip", name, 1); cp += dlen; break; case DNS_T_MX: - add_assoc_string(*subarray, "type", "MX", 1); + add_ascii_assoc_string(*subarray, "type", "MX", 1); GETSHORT(n, cp); - add_assoc_long(*subarray, "pri", n); + add_ascii_assoc_long(*subarray, "pri", n); /* no break; */ case DNS_T_CNAME: if (type == DNS_T_CNAME) - add_assoc_string(*subarray, "type", "CNAME", 1); + add_ascii_assoc_string(*subarray, "type", "CNAME", 1); /* no break; */ case DNS_T_NS: if (type == DNS_T_NS) - add_assoc_string(*subarray, "type", "NS", 1); + add_ascii_assoc_string(*subarray, "type", "NS", 1); /* no break; */ case DNS_T_PTR: if (type == DNS_T_PTR) - add_assoc_string(*subarray, "type", "PTR", 1); + add_ascii_assoc_string(*subarray, "type", "PTR", 1); n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2); if (n < 0) { return NULL; } cp += n; - add_assoc_string(*subarray, "target", name, 1); + add_ascii_assoc_string(*subarray, "target", name, 1); break; case DNS_T_HINFO: /* See RFC 1010 for values */ - add_assoc_string(*subarray, "type", "HINFO", 1); + add_ascii_assoc_string(*subarray, "type", "HINFO", 1); n = *cp & 0xFF; cp++; - add_assoc_stringl(*subarray, "cpu", (char*)cp, n, 1); + add_ascii_assoc_stringl(*subarray, "cpu", (char*)cp, n, 1); cp += n; n = *cp & 0xFF; cp++; - add_assoc_stringl(*subarray, "os", (char*)cp, n, 1); + add_ascii_assoc_stringl(*subarray, "os", (char*)cp, n, 1); cp += n; break; case DNS_T_TXT: - add_assoc_string(*subarray, "type", "TXT", 1); + add_ascii_assoc_string(*subarray, "type", "TXT", 1); n = cp[0]; tp = emalloc(n + 1); memcpy(tp, cp + 1, n); tp[n] = '\0'; cp += dlen; - add_assoc_stringl(*subarray, "txt", (char*)tp, n, 0); + add_ascii_assoc_stringl(*subarray, "txt", (char*)tp, n, 0); break; case DNS_T_SOA: - add_assoc_string(*subarray, "type", "SOA", 1); + add_ascii_assoc_string(*subarray, "type", "SOA", 1); n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2); if (n < 0) { return NULL; } cp += n; - add_assoc_string(*subarray, "mname", name, 1); + add_ascii_assoc_string(*subarray, "mname", name, 1); n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2); if (n < 0) { return NULL; } cp += n; - add_assoc_string(*subarray, "rname", name, 1); + add_ascii_assoc_string(*subarray, "rname", name, 1); GETLONG(n, cp); - add_assoc_long(*subarray, "serial", n); + add_ascii_assoc_long(*subarray, "serial", n); GETLONG(n, cp); - add_assoc_long(*subarray, "refresh", n); + add_ascii_assoc_long(*subarray, "refresh", n); GETLONG(n, cp); - add_assoc_long(*subarray, "retry", n); + add_ascii_assoc_long(*subarray, "retry", n); GETLONG(n, cp); - add_assoc_long(*subarray, "expire", n); + add_ascii_assoc_long(*subarray, "expire", n); GETLONG(n, cp); - add_assoc_long(*subarray, "minimum-ttl", n); + add_ascii_assoc_long(*subarray, "minimum-ttl", n); break; case DNS_T_AAAA: tp = (u_char*)name; @@ -533,15 +533,15 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int tp++; } tp[0] = '\0'; - add_assoc_string(*subarray, "type", "AAAA", 1); - add_assoc_string(*subarray, "ipv6", name, 1); + add_ascii_assoc_string(*subarray, "type", "AAAA", 1); + add_ascii_assoc_string(*subarray, "ipv6", name, 1); break; case DNS_T_A6: p = cp; - add_assoc_string(*subarray, "type", "A6", 1); + add_ascii_assoc_string(*subarray, "type", "A6", 1); n = ((int)cp[0]) & 0xFF; cp++; - add_assoc_long(*subarray, "masklen", n); + add_ascii_assoc_long(*subarray, "masklen", n); tp = (u_char*)name; if (n > 15) { have_v6_break = 1; @@ -601,59 +601,59 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int tp++; } tp[0] = '\0'; - add_assoc_string(*subarray, "ipv6", name, 1); + add_ascii_assoc_string(*subarray, "ipv6", name, 1); if (cp < p + dlen) { n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2); if (n < 0) { return NULL; } cp += n; - add_assoc_string(*subarray, "chain", name, 1); + add_ascii_assoc_string(*subarray, "chain", name, 1); } break; case DNS_T_SRV: - add_assoc_string(*subarray, "type", "SRV", 1); + add_ascii_assoc_string(*subarray, "type", "SRV", 1); GETSHORT(n, cp); - add_assoc_long(*subarray, "pri", n); + add_ascii_assoc_long(*subarray, "pri", n); GETSHORT(n, cp); - add_assoc_long(*subarray, "weight", n); + add_ascii_assoc_long(*subarray, "weight", n); GETSHORT(n, cp); - add_assoc_long(*subarray, "port", n); + add_ascii_assoc_long(*subarray, "port", n); n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2); if (n < 0) { return NULL; } cp += n; - add_assoc_string(*subarray, "target", name, 1); + add_ascii_assoc_string(*subarray, "target", name, 1); break; case DNS_T_NAPTR: - add_assoc_string(*subarray, "type", "NAPTR", 1); + add_ascii_assoc_string(*subarray, "type", "NAPTR", 1); GETSHORT(n, cp); - add_assoc_long(*subarray, "order", n); + add_ascii_assoc_long(*subarray, "order", n); GETSHORT(n, cp); - add_assoc_long(*subarray, "pref", n); + add_ascii_assoc_long(*subarray, "pref", n); n = (cp[0] & 0xFF); - add_assoc_stringl(*subarray, "flags", (char*)++cp, n, 1); + add_ascii_assoc_stringl(*subarray, "flags", (char*)++cp, n, 1); cp += n; n = (cp[0] & 0xFF); - add_assoc_stringl(*subarray, "services", (char*)++cp, n, 1); + add_ascii_assoc_stringl(*subarray, "services", (char*)++cp, n, 1); cp += n; n = (cp[0] & 0xFF); - add_assoc_stringl(*subarray, "regex", (char*)++cp, n, 1); + add_ascii_assoc_stringl(*subarray, "regex", (char*)++cp, n, 1); cp += n; n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2); if (n < 0) { return NULL; } cp += n; - add_assoc_string(*subarray, "replacement", name, 1); + add_ascii_assoc_string(*subarray, "replacement", name, 1); break; default: cp += dlen; } - add_assoc_string(*subarray, "class", "IN", 1); - add_assoc_long(*subarray, "ttl", ttl); + add_ascii_assoc_string(*subarray, "class", "IN", 1); + add_ascii_assoc_long(*subarray, "ttl", ttl); return cp; } diff --git a/ext/standard/file.c b/ext/standard/file.c index 6e6c1faf23..298735933e 100644 --- a/ext/standard/file.c +++ b/ext/standard/file.c @@ -1748,19 +1748,19 @@ PHP_NAMED_FUNCTION(php_if_fstat) zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL); /* Store string indexes referencing the same zval*/ - zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *)&stat_dev, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *)&stat_ino, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *)&stat_mode, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *)&stat_nlink, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *)&stat_uid, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *)&stat_gid, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *)&stat_rdev, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *)&stat_size, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *)&stat_atime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *)&stat_mtime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *)&stat_ctime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *)&stat_blksize, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *)&stat_blocks, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *)&stat_dev, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *)&stat_ino, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *)&stat_mode, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *)&stat_nlink, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *)&stat_uid, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *)&stat_gid, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *)&stat_rdev, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *)&stat_size, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *)&stat_atime, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *)&stat_mtime, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *)&stat_ctime, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *)&stat_blksize, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *)&stat_blocks, sizeof(zval *), NULL); } /* }}} */ diff --git a/ext/standard/filestat.c b/ext/standard/filestat.c index 313f89a1e7..c5aa8cc8b3 100644 --- a/ext/standard/filestat.c +++ b/ext/standard/filestat.c @@ -831,19 +831,19 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL); /* Store string indexes referencing the same zval*/ - zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *) &stat_dev, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *) &stat_ino, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *) &stat_mode, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *) &stat_nlink, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *) &stat_uid, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *) &stat_gid, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *) &stat_rdev, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *) &stat_size, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *) &stat_atime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *) &stat_mtime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *) &stat_ctime, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *) &stat_blksize, sizeof(zval *), NULL); - zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *) &stat_blocks, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *) &stat_dev, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *) &stat_ino, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *) &stat_mode, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *) &stat_nlink, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *) &stat_uid, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *) &stat_gid, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *) &stat_rdev, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *) &stat_size, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *) &stat_atime, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *) &stat_mtime, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *) &stat_ctime, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *) &stat_blksize, sizeof(zval *), NULL); + zend_ascii_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *) &stat_blocks, sizeof(zval *), NULL); return; } diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c index 8376ee81ce..ee3e39af70 100644 --- a/ext/standard/http_fopen_wrapper.c +++ b/ext/standard/http_fopen_wrapper.c @@ -512,7 +512,7 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, char *path, { zval **rh; - zend_hash_find(EG(active_symbol_table), "http_response_header", sizeof("http_response_header"), (void **) &rh); + zend_ascii_hash_find(EG(active_symbol_table), "http_response_header", sizeof("http_response_header"), (void **) &rh); response_header = *rh; } diff --git a/ext/standard/image.c b/ext/standard/image.c index b6ba4228f9..7476ed17f6 100644 --- a/ext/standard/image.c +++ b/ext/standard/image.c @@ -456,9 +456,9 @@ static int php_read_APP(php_stream * stream, unsigned int marker, zval *info TSR sprintf(markername, "APP%d", marker - M_APP0); - if (zend_hash_find(Z_ARRVAL_P(info), markername, strlen(markername)+1, (void **) &tmp) == FAILURE) { + if (zend_ascii_hash_find(Z_ARRVAL_P(info), markername, strlen(markername)+1, (void **) &tmp) == FAILURE) { /* XXX we onyl catch the 1st tag of it's kind! */ - add_assoc_stringl(info, markername, buffer, length, 1); + add_ascii_assoc_stringl(info, markername, buffer, length, 1); } efree(buffer); @@ -1399,13 +1399,13 @@ PHP_FUNCTION(getimagesize) } if (result->bits != 0) { - add_assoc_long(return_value, "bits", result->bits); + add_ascii_assoc_long(return_value, "bits", result->bits); } if (result->channels != 0) { - add_assoc_long(return_value, "channels", result->channels); + add_ascii_assoc_long(return_value, "channels", result->channels); } temp = (char*)php_image_type_to_mime_type(itype); - add_assoc_ascii_string(return_value, "mime", temp, 1); + add_ascii_assoc_ascii_string(return_value, "mime", temp, 1); efree(result); } else { RETURN_FALSE; diff --git a/ext/standard/info.c b/ext/standard/info.c index 221cad11ed..491308e489 100644 --- a/ext/standard/info.c +++ b/ext/standard/info.c @@ -713,16 +713,16 @@ PHPAPI void php_print_info(int flag TSRMLS_DC) php_info_print_table_start(); php_info_print_table_header(2, "Variable", "Value"); - if (zend_hash_find(&EG(symbol_table), "PHP_SELF", sizeof("PHP_SELF"), (void **) &data) != FAILURE) { + if (zend_ascii_hash_find(&EG(symbol_table), "PHP_SELF", sizeof("PHP_SELF"), (void **) &data) != FAILURE) { php_info_print_table_row(2, "PHP_SELF", Z_STRVAL_PP(data)); } - if (zend_hash_find(&EG(symbol_table), "PHP_AUTH_TYPE", sizeof("PHP_AUTH_TYPE"), (void **) &data) != FAILURE) { + if (zend_ascii_hash_find(&EG(symbol_table), "PHP_AUTH_TYPE", sizeof("PHP_AUTH_TYPE"), (void **) &data) != FAILURE) { php_info_print_table_row(2, "PHP_AUTH_TYPE", Z_STRVAL_PP(data)); } - if (zend_hash_find(&EG(symbol_table), "PHP_AUTH_USER", sizeof("PHP_AUTH_USER"), (void **) &data) != FAILURE) { + if (zend_ascii_hash_find(&EG(symbol_table), "PHP_AUTH_USER", sizeof("PHP_AUTH_USER"), (void **) &data) != FAILURE) { php_info_print_table_row(2, "PHP_AUTH_USER", Z_STRVAL_PP(data)); } - if (zend_hash_find(&EG(symbol_table), "PHP_AUTH_PW", sizeof("PHP_AUTH_PW"), (void **) &data) != FAILURE) { + if (zend_ascii_hash_find(&EG(symbol_table), "PHP_AUTH_PW", sizeof("PHP_AUTH_PW"), (void **) &data) != FAILURE) { php_info_print_table_row(2, "PHP_AUTH_PW", Z_STRVAL_PP(data)); } php_print_gpcse_array("_REQUEST", sizeof("_REQUEST")-1 TSRMLS_CC); diff --git a/ext/standard/iptc.c b/ext/standard/iptc.c index 45109ec296..08a6471537 100644 --- a/ext/standard/iptc.c +++ b/ext/standard/iptc.c @@ -357,12 +357,12 @@ PHP_FUNCTION(iptcparse) array_init(return_value); } - if (zend_hash_find(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void **) &element) == FAILURE) { + if (zend_ascii_hash_find(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void **) &element) == FAILURE) { ALLOC_ZVAL(values); INIT_PZVAL(values); array_init(values); - zend_hash_update(Z_ARRVAL_P(return_value), key, strlen(key)+1, (void *) &values, sizeof(zval*), (void **) &element); + zend_ascii_hash_update(Z_ARRVAL_P(return_value), key, strlen(key)+1, (void *) &values, sizeof(zval*), (void **) &element); } add_next_index_stringl(*element, (char*)buffer+inx, len, 1); diff --git a/ext/standard/microtime.c b/ext/standard/microtime.c index 36c9409688..c9d8b971eb 100644 --- a/ext/standard/microtime.c +++ b/ext/standard/microtime.c @@ -74,11 +74,11 @@ static void _php_gettimeofday(INTERNAL_FUNCTION_PARAMETERS, int mode) offset = timelib_get_time_zone_info(tp.tv_sec, get_timezone_info(TSRMLS_C)); array_init(return_value); - add_assoc_long(return_value, "sec", tp.tv_sec); - add_assoc_long(return_value, "usec", tp.tv_usec); + add_ascii_assoc_long(return_value, "sec", tp.tv_sec); + add_ascii_assoc_long(return_value, "usec", tp.tv_usec); - add_assoc_long(return_value, "minuteswest", -offset->offset / SEC_IN_MIN); - add_assoc_long(return_value, "dsttime", offset->is_dst); + add_ascii_assoc_long(return_value, "minuteswest", -offset->offset / SEC_IN_MIN); + add_ascii_assoc_long(return_value, "dsttime", offset->is_dst); timelib_time_offset_dtor(offset); } else { @@ -127,7 +127,7 @@ PHP_FUNCTION(getrusage) array_init(return_value); #define PHP_RUSAGE_PARA(a) \ - add_assoc_long(return_value, #a, usg.a) + add_ascii_assoc_long(return_value, #a, usg.a) #if !defined( _OSD_POSIX) && !defined(__BEOS__) /* BS2000 has only a few fields in the rusage struct */ PHP_RUSAGE_PARA(ru_oublock); PHP_RUSAGE_PARA(ru_inblock); diff --git a/ext/standard/proc_open.c b/ext/standard/proc_open.c index 5b2d54de6e..62adfbd38e 100644 --- a/ext/standard/proc_open.c +++ b/ext/standard/proc_open.c @@ -319,8 +319,8 @@ PHP_FUNCTION(proc_get_status) array_init(return_value); - add_assoc_string(return_value, "command", proc->command, 1); - add_assoc_long(return_value, "pid", (long) proc->child); + add_ascii_assoc_string(return_value, "command", proc->command, 1); + add_ascii_assoc_long(return_value, "pid", (long) proc->child); #ifdef PHP_WIN32 @@ -357,12 +357,12 @@ PHP_FUNCTION(proc_get_status) } #endif - add_assoc_bool(return_value, "running", running); - add_assoc_bool(return_value, "signaled", signaled); - add_assoc_bool(return_value, "stopped", stopped); - add_assoc_long(return_value, "exitcode", exitcode); - add_assoc_long(return_value, "termsig", termsig); - add_assoc_long(return_value, "stopsig", stopsig); + add_ascii_assoc_bool(return_value, "running", running); + add_ascii_assoc_bool(return_value, "signaled", signaled); + add_ascii_assoc_bool(return_value, "stopped", stopped); + add_ascii_assoc_long(return_value, "exitcode", exitcode); + add_ascii_assoc_long(return_value, "termsig", termsig); + add_ascii_assoc_long(return_value, "stopsig", stopsig); } /* }}} */ @@ -456,7 +456,7 @@ PHP_FUNCTION(proc_open) #ifdef PHP_WIN32 if (other_options) { zval **item; - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(other_options), "suppress_errors", sizeof("suppress_errors"), (void**)&item)) { + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(other_options), "suppress_errors", sizeof("suppress_errors"), (void**)&item)) { if (Z_TYPE_PP(item) == IS_BOOL && Z_BVAL_PP(item)) { suppress_errors = 1; } diff --git a/ext/standard/scanf.c b/ext/standard/scanf.c index b21668836a..cbd5c5bc6f 100644 --- a/ext/standard/scanf.c +++ b/ext/standard/scanf.c @@ -656,11 +656,15 @@ PHPAPI int php_sscanf_internal( char *string, char *format, */ if (!numVars) { + zval *tmp; + /* allocate an array for return */ array_init(*return_value); for (i = 0; i < totalVars; i++) { - if (add_next_index_null(*return_value) == FAILURE) { + MAKE_STD_ZVAL(tmp); + ZVAL_NULL(tmp); + if (add_next_index_zval(*return_value, tmp) == FAILURE) { scan_set_error_return(0, return_value); return FAILURE; } diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c index f07b3acedb..9b08f9c058 100644 --- a/ext/standard/streamsfuncs.c +++ b/ext/standard/streamsfuncs.c @@ -458,14 +458,14 @@ PHP_FUNCTION(stream_get_meta_data) zval_copy_ctor(newval); INIT_PZVAL(newval); - add_assoc_zval(return_value, "wrapper_data", newval); + add_ascii_assoc_zval(return_value, "wrapper_data", newval); } if (stream->wrapper) { - add_assoc_string(return_value, "wrapper_type", (char *)stream->wrapper->wops->label, 1); + add_ascii_assoc_string(return_value, "wrapper_type", (char *)stream->wrapper->wops->label, 1); } - add_assoc_string(return_value, "stream_type", (char *)stream->ops->label, 1); + add_ascii_assoc_string(return_value, "stream_type", (char *)stream->ops->label, 1); - add_assoc_string(return_value, "mode", stream->mode, 1); + add_ascii_assoc_string(return_value, "mode", stream->mode, 1); if (stream->readfilters.head) { php_stream_filter *filter; @@ -477,7 +477,7 @@ PHP_FUNCTION(stream_get_meta_data) add_next_index_string(newval, filter->name, 1); } - add_assoc_zval(return_value, "read_filters", newval); + add_ascii_assoc_zval(return_value, "read_filters", newval); } if (stream->writefilters.head) { @@ -490,27 +490,27 @@ PHP_FUNCTION(stream_get_meta_data) add_next_index_string(newval, filter->name, 1); } - add_assoc_zval(return_value, "write_filters", newval); + add_ascii_assoc_zval(return_value, "write_filters", newval); } if (stream->readbuf_type == IS_UNICODE) { int readbuf_len = u_countChar32(stream->readbuf.u + stream->readpos, stream->writepos - stream->readpos); - add_assoc_long(return_value, "unread_bytes", UBYTES(stream->writepos - stream->readpos)); - add_assoc_long(return_value, "unread_chars", readbuf_len); + add_ascii_assoc_long(return_value, "unread_bytes", UBYTES(stream->writepos - stream->readpos)); + add_ascii_assoc_long(return_value, "unread_chars", readbuf_len); } else { /* IS_STRING */ - add_assoc_long(return_value, "unread_bytes", stream->writepos - stream->readpos); - add_assoc_long(return_value, "unread_chars", stream->writepos - stream->readpos); + add_ascii_assoc_long(return_value, "unread_bytes", stream->writepos - stream->readpos); + add_ascii_assoc_long(return_value, "unread_chars", stream->writepos - stream->readpos); } - add_assoc_bool(return_value, "seekable", (stream->ops->seek) && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0); + add_ascii_assoc_bool(return_value, "seekable", (stream->ops->seek) && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0); if (stream->orig_path) { - add_assoc_string(return_value, "uri", stream->orig_path, 1); + add_ascii_assoc_string(return_value, "uri", stream->orig_path, 1); } if (!php_stream_populate_meta_data(stream, return_value)) { - add_assoc_bool(return_value, "timed_out", 0); - add_assoc_bool(return_value, "blocked", 1); - add_assoc_bool(return_value, "eof", php_stream_eof(stream)); + add_ascii_assoc_bool(return_value, "timed_out", 0); + add_ascii_assoc_bool(return_value, "blocked", 1); + add_ascii_assoc_bool(return_value, "eof", php_stream_eof(stream)); } } @@ -914,7 +914,7 @@ static int parse_context_params(php_stream_context *context, zval *params TSRMLS int ret = SUCCESS; zval **tmp; - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "notification", sizeof("notification"), (void**)&tmp)) { + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(params), "notification", sizeof("notification"), (void**)&tmp)) { if (context->notifier) { php_stream_notification_free(context->notifier); @@ -927,10 +927,10 @@ static int parse_context_params(php_stream_context *context, zval *params TSRMLS ZVAL_ADDREF(*tmp); context->notifier->dtor = user_space_stream_notifier_dtor; } - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "options", sizeof("options"), (void**)&tmp)) { + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(params), "options", sizeof("options"), (void**)&tmp)) { parse_context_options(context, *tmp TSRMLS_CC); } - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "encoding", sizeof("encoding"), (void**)&tmp)) { + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(params), "encoding", sizeof("encoding"), (void**)&tmp)) { zval strval = **tmp; if (context->input_encoding) { @@ -944,7 +944,7 @@ static int parse_context_params(php_stream_context *context, zval *params TSRMLS context->input_encoding = Z_STRVAL(strval); context->output_encoding = estrdup(Z_STRVAL(strval)); } - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "input_encoding", sizeof("input_encoding"), (void**)&tmp)) { + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(params), "input_encoding", sizeof("input_encoding"), (void**)&tmp)) { zval strval = **tmp; if (context->input_encoding) { @@ -955,7 +955,7 @@ static int parse_context_params(php_stream_context *context, zval *params TSRMLS convert_to_string(&strval); context->input_encoding = Z_STRVAL(strval); } - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "output_encoding", sizeof("output_encoding"), (void**)&tmp)) { + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(params), "output_encoding", sizeof("output_encoding"), (void**)&tmp)) { zval strval = **tmp; if (context->output_encoding) { @@ -966,7 +966,7 @@ static int parse_context_params(php_stream_context *context, zval *params TSRMLS convert_to_string(&strval); context->output_encoding = Z_STRVAL(strval); } - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "default_mode", sizeof("default_mode"), (void**)&tmp)) { + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(params), "default_mode", sizeof("default_mode"), (void**)&tmp)) { zval longval = **tmp; zval_copy_ctor(&longval); diff --git a/ext/standard/string.c b/ext/standard/string.c index 245ac83214..c738b87fbd 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -2076,7 +2076,7 @@ PHP_FUNCTION(pathinfo) ret_len = php_dirname(ret.s, path_len); } if (ret_len > 0) { - add_assoc_zstrl(tmp, "dirname", path_type, ret, ret_len, 1); + add_ascii_assoc_zstrl(tmp, "dirname", path_type, ret, ret_len, 1); } efree(ret.v); ret = NULL_ZSTR; @@ -2091,7 +2091,7 @@ PHP_FUNCTION(pathinfo) } if (have_basename) { - add_assoc_zstrl(tmp, "basename", path_type, ret, ret_len, 0); + add_ascii_assoc_zstrl(tmp, "basename", path_type, ret, ret_len, 0); } if (have_ext) { @@ -2113,7 +2113,7 @@ PHP_FUNCTION(pathinfo) } if (ext.v) { - add_assoc_zstrl(tmp, "extension", path_type, ext, ext_len, 1); + add_ascii_assoc_zstrl(tmp, "extension", path_type, ext, ext_len, 1); } } @@ -2129,7 +2129,7 @@ PHP_FUNCTION(pathinfo) idx = p.s ? (p.s - ret.s) : ret_len; } - add_assoc_zstrl(tmp, "filename", path_type, ret, idx, 1); + add_ascii_assoc_zstrl(tmp, "filename", path_type, ret, idx, 1); } if (!have_basename && ret.v) { @@ -5112,6 +5112,8 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit /* For each subject entry, convert it to string, then perform replacement and add the result to the return_value array. */ while (zend_hash_get_current_data(Z_ARRVAL_PP(subject), (void **)&subject_entry) == SUCCESS) { + zend_uchar utype; + if (Z_TYPE_PP(subject_entry) != IS_ARRAY && Z_TYPE_PP(subject_entry) != IS_OBJECT) { MAKE_STD_ZVAL(result); SEPARATE_ZVAL(subject_entry); @@ -5122,11 +5124,11 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit COPY_PZVAL_TO_ZVAL(*result, *subject_entry); } /* Add to return array */ - switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(subject), &string_key, - &string_key_len, &num_key, 0, NULL)) { + switch ((utype = zend_hash_get_current_key_ex(Z_ARRVAL_PP(subject), &string_key, + &string_key_len, &num_key, 0, NULL))) { case HASH_KEY_IS_STRING: case HASH_KEY_IS_UNICODE: - add_assoc_zval_ex(return_value, string_key.s, string_key_len, result); + add_u_assoc_zval_ex(return_value, utype, string_key, string_key_len, result); break; case HASH_KEY_IS_LONG: @@ -6456,22 +6458,22 @@ PHP_FUNCTION(localeconv) add_index_long(mon_grouping, i, currlocdata.mon_grouping[i]); } - add_assoc_string(return_value, "decimal_point", currlocdata.decimal_point, 1); - add_assoc_string(return_value, "thousands_sep", currlocdata.thousands_sep, 1); - add_assoc_string(return_value, "int_curr_symbol", currlocdata.int_curr_symbol, 1); - add_assoc_string(return_value, "currency_symbol", currlocdata.currency_symbol, 1); - add_assoc_string(return_value, "mon_decimal_point", currlocdata.mon_decimal_point, 1); - add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep, 1); - add_assoc_string(return_value, "positive_sign", currlocdata.positive_sign, 1); - add_assoc_string(return_value, "negative_sign", currlocdata.negative_sign, 1); - add_assoc_long( return_value, "int_frac_digits", currlocdata.int_frac_digits ); - add_assoc_long( return_value, "frac_digits", currlocdata.frac_digits ); - add_assoc_long( return_value, "p_cs_precedes", currlocdata.p_cs_precedes ); - add_assoc_long( return_value, "p_sep_by_space", currlocdata.p_sep_by_space ); - add_assoc_long( return_value, "n_cs_precedes", currlocdata.n_cs_precedes ); - add_assoc_long( return_value, "n_sep_by_space", currlocdata.n_sep_by_space ); - add_assoc_long( return_value, "p_sign_posn", currlocdata.p_sign_posn ); - add_assoc_long( return_value, "n_sign_posn", currlocdata.n_sign_posn ); + add_ascii_assoc_string(return_value, "decimal_point", currlocdata.decimal_point, 1); + add_ascii_assoc_string(return_value, "thousands_sep", currlocdata.thousands_sep, 1); + add_ascii_assoc_string(return_value, "int_curr_symbol", currlocdata.int_curr_symbol, 1); + add_ascii_assoc_string(return_value, "currency_symbol", currlocdata.currency_symbol, 1); + add_ascii_assoc_string(return_value, "mon_decimal_point", currlocdata.mon_decimal_point, 1); + add_ascii_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep, 1); + add_ascii_assoc_string(return_value, "positive_sign", currlocdata.positive_sign, 1); + add_ascii_assoc_string(return_value, "negative_sign", currlocdata.negative_sign, 1); + add_ascii_assoc_long( return_value, "int_frac_digits", currlocdata.int_frac_digits ); + add_ascii_assoc_long( return_value, "frac_digits", currlocdata.frac_digits ); + add_ascii_assoc_long( return_value, "p_cs_precedes", currlocdata.p_cs_precedes ); + add_ascii_assoc_long( return_value, "p_sep_by_space", currlocdata.p_sep_by_space ); + add_ascii_assoc_long( return_value, "n_cs_precedes", currlocdata.n_cs_precedes ); + add_ascii_assoc_long( return_value, "n_sep_by_space", currlocdata.n_sep_by_space ); + add_ascii_assoc_long( return_value, "p_sign_posn", currlocdata.p_sign_posn ); + add_ascii_assoc_long( return_value, "n_sign_posn", currlocdata.n_sign_posn ); } #else /* Ok, it doesn't look like we have locale info floating around, so I guess it @@ -6480,26 +6482,26 @@ PHP_FUNCTION(localeconv) add_index_long(grouping, 0, -1); add_index_long(mon_grouping, 0, -1); - add_assoc_string(return_value, "decimal_point", "\x2E", 1); - add_assoc_string(return_value, "thousands_sep", "", 1); - add_assoc_string(return_value, "int_curr_symbol", "", 1); - add_assoc_string(return_value, "currency_symbol", "", 1); - add_assoc_string(return_value, "mon_decimal_point", "\x2E", 1); - add_assoc_string(return_value, "mon_thousands_sep", "", 1); - add_assoc_string(return_value, "positive_sign", "", 1); - add_assoc_string(return_value, "negative_sign", "", 1); - add_assoc_long( return_value, "int_frac_digits", CHAR_MAX ); - add_assoc_long( return_value, "frac_digits", CHAR_MAX ); - add_assoc_long( return_value, "p_cs_precedes", CHAR_MAX ); - add_assoc_long( return_value, "p_sep_by_space", CHAR_MAX ); - add_assoc_long( return_value, "n_cs_precedes", CHAR_MAX ); - add_assoc_long( return_value, "n_sep_by_space", CHAR_MAX ); - add_assoc_long( return_value, "p_sign_posn", CHAR_MAX ); - add_assoc_long( return_value, "n_sign_posn", CHAR_MAX ); + add_ascii_assoc_string(return_value, "decimal_point", "\x2E", 1); + add_ascii_assoc_string(return_value, "thousands_sep", "", 1); + add_ascii_assoc_string(return_value, "int_curr_symbol", "", 1); + add_ascii_assoc_string(return_value, "currency_symbol", "", 1); + add_ascii_assoc_string(return_value, "mon_decimal_point", "\x2E", 1); + add_ascii_assoc_string(return_value, "mon_thousands_sep", "", 1); + add_ascii_assoc_string(return_value, "positive_sign", "", 1); + add_ascii_assoc_string(return_value, "negative_sign", "", 1); + add_ascii_assoc_long( return_value, "int_frac_digits", CHAR_MAX ); + add_ascii_assoc_long( return_value, "frac_digits", CHAR_MAX ); + add_ascii_assoc_long( return_value, "p_cs_precedes", CHAR_MAX ); + add_ascii_assoc_long( return_value, "p_sep_by_space", CHAR_MAX ); + add_ascii_assoc_long( return_value, "n_cs_precedes", CHAR_MAX ); + add_ascii_assoc_long( return_value, "n_sep_by_space", CHAR_MAX ); + add_ascii_assoc_long( return_value, "p_sign_posn", CHAR_MAX ); + add_ascii_assoc_long( return_value, "n_sign_posn", CHAR_MAX ); #endif - zend_hash_update(Z_ARRVAL_P(return_value), "grouping", 9, &grouping, sizeof(zval *), NULL); - zend_hash_update(Z_ARRVAL_P(return_value), "mon_grouping", 13, &mon_grouping, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(return_value), "grouping", 9, &grouping, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(return_value), "mon_grouping", 13, &mon_grouping, sizeof(zval *), NULL); } /* }}} */ @@ -7076,7 +7078,7 @@ PHP_FUNCTION(str_split) array_init(return_value); if (split_length >= str_len) { - add_next_index_zstrl(return_value, str, str_len, str_type, 1); + add_next_index_zstrl(return_value, str_type, str, str_len, 1); return; } @@ -7087,12 +7089,12 @@ PHP_FUNCTION(str_split) } while (n_reg_segments-- > 0) { - add_next_index_zstrl(return_value, ZSTR(p), split_length, str_type, 1); + add_next_index_zstrl(return_value, str_type, ZSTR(p), split_length, 1); p += split_length * charsize; } if (p != (str.s + str_len * charsize)) { - add_next_index_zstrl(return_value, ZSTR(p), (str.s + str_len * charsize - p), str_type, 1); + add_next_index_zstrl(return_value, str_type, ZSTR(p), (str.s + str_len * charsize - p), 1); } } /* }}} */ diff --git a/ext/standard/url.c b/ext/standard/url.c index 2a6a617eb1..ac870f84dc 100644 --- a/ext/standard/url.c +++ b/ext/standard/url.c @@ -386,21 +386,21 @@ PHP_FUNCTION(parse_url) /* add the various elements to the array */ if (resource->scheme != NULL) - add_assoc_string(return_value, "scheme", resource->scheme, 1); + add_ascii_assoc_string(return_value, "scheme", resource->scheme, 1); if (resource->host != NULL) - add_assoc_string(return_value, "host", resource->host, 1); + add_ascii_assoc_string(return_value, "host", resource->host, 1); if (resource->port != 0) - add_assoc_long(return_value, "port", resource->port); + add_ascii_assoc_long(return_value, "port", resource->port); if (resource->user != NULL) - add_assoc_string(return_value, "user", resource->user, 1); + add_ascii_assoc_string(return_value, "user", resource->user, 1); if (resource->pass != NULL) - add_assoc_string(return_value, "pass", resource->pass, 1); + add_ascii_assoc_string(return_value, "pass", resource->pass, 1); if (resource->path != NULL) - add_assoc_string(return_value, "path", resource->path, 1); + add_ascii_assoc_string(return_value, "path", resource->path, 1); if (resource->query != NULL) - add_assoc_string(return_value, "query", resource->query, 1); + add_ascii_assoc_string(return_value, "query", resource->query, 1); if (resource->fragment != NULL) - add_assoc_string(return_value, "fragment", resource->fragment, 1); + add_ascii_assoc_string(return_value, "fragment", resource->fragment, 1); done: php_url_free(resource); } diff --git a/ext/zlib/zlib.c b/ext/zlib/zlib.c index 7e427da5f8..86b2b0afc8 100644 --- a/ext/zlib/zlib.c +++ b/ext/zlib/zlib.c @@ -57,7 +57,7 @@ int php_zlib_output_encoding(TSRMLS_D) if (!ZLIBG(compression_coding)) { zend_is_auto_global(ZEND_STRL("_SERVER") TSRMLS_CC); - if (PG(http_globals)[TRACK_VARS_SERVER] && SUCCESS == zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), (void *) &enc)) { + if (PG(http_globals)[TRACK_VARS_SERVER] && SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), (void *) &enc)) { convert_to_string(*enc); if (strstr(Z_STRVAL_PP(enc), "gzip")) { ZLIBG(compression_coding) = PHP_ZLIB_ENCODING_GZIP; diff --git a/main/main.c b/main/main.c index 9a14a1c475..9121c92698 100644 --- a/main/main.c +++ b/main/main.c @@ -685,7 +685,7 @@ PHPAPI void php_verror(const char *docref, const char *params, int type, const c zval *tmp; ALLOC_INIT_ZVAL(tmp); ZVAL_RT_STRINGL(tmp, buffer, buffer_len, 1); - zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) &tmp, sizeof(zval *), NULL); + zend_ascii_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) &tmp, sizeof(zval *), NULL); } efree(buffer); } @@ -950,7 +950,7 @@ static void php_error_cb(int type, const char *error_filename, const uint error_ ALLOC_INIT_ZVAL(tmp); ZVAL_RT_STRINGL(tmp, buffer, buffer_len, 1); - zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) & tmp, sizeof(zval *), NULL); + zend_ascii_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) & tmp, sizeof(zval *), NULL); } efree(buffer); } @@ -1735,7 +1735,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod if (sapi_module.additional_functions) { zend_module_entry *module; - if (zend_hash_find(&module_registry, "standard", sizeof("standard"), (void**)&module)==SUCCESS) { + if (zend_ascii_hash_find(&module_registry, "standard", sizeof("standard"), (void**)&module)==SUCCESS) { EG(current_module) = module; zend_register_functions(NULL, sapi_module.additional_functions, NULL, MODULE_PERSISTENT TSRMLS_CC); EG(current_module) = NULL; diff --git a/main/output.c b/main/output.c index 765d9e2b99..eb56752626 100644 --- a/main/output.c +++ b/main/output.c @@ -548,12 +548,12 @@ PHPAPI int php_output_handler_start(php_output_handler *handler TSRMLS_DC) if (php_output_lock_error(PHP_OUTPUT_HANDLER_START TSRMLS_CC) || !handler) { return FAILURE; } - if (SUCCESS == zend_u_hash_find(&php_output_handler_conflicts, Z_TYPE_P(handler->name), Z_UNIVAL_P(handler->name), Z_UNILEN_P(handler->name), (void *) &conflict)) { + if (SUCCESS == zend_u_hash_find(&php_output_handler_conflicts, Z_TYPE_P(handler->name), Z_UNIVAL_P(handler->name), Z_UNILEN_P(handler->name)+1, (void *) &conflict)) { if (SUCCESS != (*conflict)(handler->name TSRMLS_CC)) { return FAILURE; } } - if (SUCCESS == zend_u_hash_find(&php_output_handler_reverse_conflicts, Z_TYPE_P(handler->name), Z_UNIVAL_P(handler->name), Z_UNILEN_P(handler->name), (void *) &rconflicts)) { + if (SUCCESS == zend_u_hash_find(&php_output_handler_reverse_conflicts, Z_TYPE_P(handler->name), Z_UNIVAL_P(handler->name), Z_UNILEN_P(handler->name)+1, (void *) &rconflicts)) { for ( zend_hash_internal_pointer_reset_ex(rconflicts, &pos); zend_hash_get_current_data_ex(rconflicts, (void *) &conflict, &pos) == SUCCESS; zend_hash_move_forward_ex(rconflicts, &pos)) { @@ -616,7 +616,7 @@ PHPAPI int php_output_handler_conflict_register(zval *name, php_output_handler_c zend_error(E_ERROR, "Cannot register an output handler conflict outside of MINIT"); return FAILURE; } - return zend_u_hash_update(&php_output_handler_conflicts, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name), &check_func, sizeof(php_output_handler_conflict_check_t *), NULL); + return zend_u_hash_update(&php_output_handler_conflicts, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name)+1, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL); } /* }}} */ @@ -630,7 +630,7 @@ PHPAPI int php_output_handler_reverse_conflict_register(zval *name, php_output_h zend_error(E_ERROR, "Cannot register a reverse output handler conflict outside of MINIT"); return FAILURE; } - if (SUCCESS == zend_u_hash_find(&php_output_handler_reverse_conflicts, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name), (void *) &rev_ptr)) { + if (SUCCESS == zend_u_hash_find(&php_output_handler_reverse_conflicts, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name)+1, (void *) &rev_ptr)) { return zend_hash_next_index_insert(rev_ptr, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL); } else { zend_u_hash_init(&rev, 1, NULL, NULL, 1, 1); @@ -638,7 +638,7 @@ PHPAPI int php_output_handler_reverse_conflict_register(zval *name, php_output_h zend_hash_destroy(&rev); return FAILURE; } - if (SUCCESS != zend_u_hash_update(&php_output_handler_reverse_conflicts, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name), &rev, sizeof(HashTable), NULL)) { + if (SUCCESS != zend_u_hash_update(&php_output_handler_reverse_conflicts, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name)+1, &rev, sizeof(HashTable), NULL)) { zend_hash_destroy(&rev); return FAILURE; } @@ -653,7 +653,7 @@ PHPAPI php_output_handler_alias_ctor_t *php_output_handler_alias(zval *name TSRM { php_output_handler_alias_ctor_t *func = NULL; - zend_u_hash_find(&php_output_handler_aliases, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name), (void *) &func); + zend_u_hash_find(&php_output_handler_aliases, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name)+1, (void *) &func); return func; } /* }}} */ @@ -666,7 +666,7 @@ PHPAPI int php_output_handler_alias_register(zval *name, php_output_handler_alia zend_error(E_ERROR, "Cannot register an output handler alias outside of MINIT"); return FAILURE; } - return zend_u_hash_update(&php_output_handler_aliases, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name), &func, sizeof(php_output_handler_alias_ctor_t *), NULL); + return zend_u_hash_update(&php_output_handler_aliases, Z_TYPE_P(name), Z_UNIVAL_P(name), Z_UNILEN_P(name)+1, &func, sizeof(php_output_handler_alias_ctor_t *), NULL); } /* }}} */ @@ -1174,13 +1174,13 @@ static inline zval *php_output_handler_status(php_output_handler *handler, zval } ZVAL_ADDREF(handler->name); - add_assoc_zval(entry, "name", handler->name); - add_assoc_long(entry, "type", (long) (handler->flags & 0xf)); - add_assoc_long(entry, "flags", (long) handler->flags); - add_assoc_long(entry, "level", (long) handler->level); - add_assoc_long(entry, "chunk_size", (long) handler->size); - add_assoc_long(entry, "buffer_size", (long) handler->buffer.size); - add_assoc_long(entry, "buffer_used", (long) handler->buffer.used); + add_ascii_assoc_zval(entry, "name", handler->name); + add_ascii_assoc_long(entry, "type", (long) (handler->flags & 0xf)); + add_ascii_assoc_long(entry, "flags", (long) handler->flags); + add_ascii_assoc_long(entry, "level", (long) handler->level); + add_ascii_assoc_long(entry, "chunk_size", (long) handler->size); + add_ascii_assoc_long(entry, "buffer_size", (long) handler->buffer.size); + add_ascii_assoc_long(entry, "buffer_used", (long) handler->buffer.used); return entry; } diff --git a/main/php_variables.c b/main/php_variables.c index e9bdb0009e..ac54c5a4a1 100644 --- a/main/php_variables.c +++ b/main/php_variables.c @@ -160,11 +160,11 @@ PHPAPI void php_register_variable_ex(char *var, zval *val, zval *track_vars_arra array_init(gpc_element); zend_hash_next_index_insert(symtable1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p); } else { - if (zend_symtable_find(symtable1, index, index_len + 1, (void **) &gpc_element_p) == FAILURE + if (zend_rt_symtable_find(symtable1, index, index_len + 1, (void **) &gpc_element_p) == FAILURE || Z_TYPE_PP(gpc_element_p) != IS_ARRAY) { MAKE_STD_ZVAL(gpc_element); array_init(gpc_element); - zend_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p); + zend_rt_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p); } } symtable1 = Z_ARRVAL_PP(gpc_element_p); @@ -196,10 +196,10 @@ plain_var: */ if (PG(http_globals)[TRACK_VARS_COOKIE] && symtable1 == Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_COOKIE]) && - zend_symtable_exists(symtable1, index, index_len+1)) { + zend_rt_symtable_exists(symtable1, index, index_len+1)) { zval_ptr_dtor(&gpc_element); } else { - zend_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p); + zend_rt_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p); } } } @@ -687,14 +687,14 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC) if (SG(request_info).argc) { arr->refcount++; argc->refcount++; - zend_hash_update(&EG(symbol_table), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL); - zend_hash_add(&EG(symbol_table), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL); + zend_ascii_hash_update(&EG(symbol_table), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL); + zend_ascii_hash_add(&EG(symbol_table), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL); } if (track_vars_array) { arr->refcount++; argc->refcount++; - zend_hash_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL); - zend_hash_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL); } zval_ptr_dtor(&arr); zval_ptr_dtor(&argc); @@ -893,7 +893,7 @@ int php_hash_environment(TSRMLS_D) } PG(http_globals)[i]->refcount++; - zend_hash_update(&EG(symbol_table), auto_global_records[i].name, auto_global_records[i].name_len, &PG(http_globals)[i], sizeof(zval *), NULL); + zend_ascii_hash_update(&EG(symbol_table), auto_global_records[i].name, auto_global_records[i].name_len, &PG(http_globals)[i], sizeof(zval *), NULL); } /* Create _REQUEST */ @@ -915,12 +915,12 @@ static zend_bool php_auto_globals_create_server(char *name, uint name_len TSRMLS if (SG(request_info).argc) { zval **argc, **argv; - if (zend_hash_find(&EG(symbol_table), "argc", sizeof("argc"), (void**)&argc) == SUCCESS && - zend_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void**)&argv) == SUCCESS) { + if (zend_ascii_hash_find(&EG(symbol_table), "argc", sizeof("argc"), (void**)&argc) == SUCCESS && + zend_ascii_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void**)&argv) == SUCCESS) { (*argc)->refcount++; (*argv)->refcount++; - zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), argv, sizeof(zval *), NULL); - zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc"), argc, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), argv, sizeof(zval *), NULL); + zend_ascii_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc"), argc, sizeof(zval *), NULL); } } else { php_build_argv(SG(request_info).query_string, PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC); @@ -938,7 +938,7 @@ static zend_bool php_auto_globals_create_server(char *name, uint name_len TSRMLS PG(http_globals)[TRACK_VARS_SERVER] = server_vars; } - zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL); + zend_ascii_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL); PG(http_globals)[TRACK_VARS_SERVER]->refcount++; return 0; /* don't rearm */ @@ -959,7 +959,7 @@ static zend_bool php_auto_globals_create_env(char *name, uint name_len TSRMLS_DC php_import_environment_variables(PG(http_globals)[TRACK_VARS_ENV] TSRMLS_CC); } - zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL); + zend_ascii_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL); PG(http_globals)[TRACK_VARS_ENV]->refcount++; return 0; /* don't rearm */ @@ -1001,7 +1001,7 @@ static zend_bool php_auto_globals_create_request(char *name, uint name_len TSRML } } - zend_hash_update(&EG(symbol_table), "_REQUEST", sizeof("_REQUEST"), &form_variables, sizeof(zval *), NULL); + zend_ascii_hash_update(&EG(symbol_table), "_REQUEST", sizeof("_REQUEST"), &form_variables, sizeof(zval *), NULL); return 0; } diff --git a/main/streams/filter.c b/main/streams/filter.c index 578eea6967..935af34f59 100644 --- a/main/streams/filter.c +++ b/main/streams/filter.c @@ -826,9 +826,9 @@ PHPAPI int _php_stream_encoding_apply(php_stream *stream, int writechain, const ALLOC_INIT_ZVAL(filterparams); array_init(filterparams); - add_assoc_long(filterparams, "error_mode", error_mode); + add_ascii_assoc_long(filterparams, "error_mode", error_mode); if (subst) { - add_assoc_unicode(filterparams, "subst_char", subst, 1); + add_ascii_assoc_unicode(filterparams, "subst_char", subst, 1); } filter = php_stream_filter_create(buf, filterparams, php_stream_is_persistent(stream) TSRMLS_CC); efree(buf); diff --git a/main/streams/memory.c b/main/streams/memory.c index 0f57ad9886..f8e043fc09 100644 --- a/main/streams/memory.c +++ b/main/streams/memory.c @@ -603,11 +603,11 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, cha MAKE_STD_ZVAL(meta); array_init(meta); if (!semi) { /* there is only a mime type */ - add_assoc_stringl(meta, "mediatype", path, mlen, 1); + add_ascii_assoc_stringl(meta, "mediatype", path, mlen, 1); mlen = 0; } else if (sep && sep < semi) { /* there is a mime type */ plen = semi - path; - add_assoc_stringl(meta, "mediatype", path, plen, 1); + add_ascii_assoc_stringl(meta, "mediatype", path, plen, 1); mlen -= plen; path += plen; } else if (semi != path || mlen != sizeof(";base64")-1 || memcmp(path, ";base64", sizeof(";base64")-1)) { /* must be error since parameters are only allowed after mediatype */ @@ -637,7 +637,7 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, cha plen = sep - path; vlen = (semi ? semi - sep : mlen - plen) - 1 /* '=' */; key = estrndup(path, plen); - add_assoc_stringl_ex(meta, key, plen + 1, sep + 1, vlen, 1); + add_rt_assoc_stringl_ex(meta, key, plen + 1, sep + 1, vlen, 1); efree(key); plen += vlen + 1; mlen -= plen; @@ -652,7 +652,7 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, cha MAKE_STD_ZVAL(meta); array_init(meta); } - add_assoc_bool(meta, "base64", base64); + add_ascii_assoc_bool(meta, "base64", base64); /* skip ',' */ comma++; diff --git a/main/streams/streams.c b/main/streams/streams.c index 5b2266d115..4176dcb850 100755 --- a/main/streams/streams.c +++ b/main/streams/streams.c @@ -2408,10 +2408,10 @@ PHPAPI int php_stream_context_get_option(php_stream_context *context, { zval **wrapperhash; - if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) { + if (FAILURE == zend_rt_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) { return FAILURE; } - return zend_hash_find(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)optionvalue); + return zend_rt_hash_find(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)optionvalue); } PHPAPI int php_stream_context_set_option(php_stream_context *context, @@ -2425,16 +2425,16 @@ PHPAPI int php_stream_context_set_option(php_stream_context *context, zval_copy_ctor(copied_val); INIT_PZVAL(copied_val); - if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) { + if (FAILURE == zend_rt_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) { MAKE_STD_ZVAL(category); array_init(category); - if (FAILURE == zend_hash_update(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&category, sizeof(zval *), NULL)) { + if (FAILURE == zend_rt_hash_update(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&category, sizeof(zval *), NULL)) { return FAILURE; } wrapperhash = &category; } - return zend_hash_update(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)&copied_val, sizeof(zval *), NULL); + return zend_rt_hash_update(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)&copied_val, sizeof(zval *), NULL); } PHPAPI int php_stream_context_get_link(php_stream_context *context, @@ -2445,7 +2445,7 @@ PHPAPI int php_stream_context_get_link(php_stream_context *context, if (!stream || !hostent || !context || !(context->links)) { return FAILURE; } - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&pstream)) { + if (SUCCESS == zend_rt_hash_find(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&pstream)) { *stream = *pstream; return SUCCESS; } @@ -2464,9 +2464,9 @@ PHPAPI int php_stream_context_set_link(php_stream_context *context, } if (!stream) { /* Delete any entry for */ - return zend_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1); + return zend_rt_hash_del(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1); } - return zend_hash_update(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&stream, sizeof(php_stream *), NULL); + return zend_rt_hash_update(Z_ARRVAL_P(context->links), (char*)hostent, strlen(hostent)+1, (void**)&stream, sizeof(php_stream *), NULL); } PHPAPI int php_stream_context_del_link(php_stream_context *context, diff --git a/main/streams/unicode_filter.c b/main/streams/unicode_filter.c index b4c886a114..84041773f5 100644 --- a/main/streams/unicode_filter.c +++ b/main/streams/unicode_filter.c @@ -313,7 +313,7 @@ static php_stream_filter *php_unicode_filter_create(const char *filtername, zval if (filterparams && Z_TYPE_P(filterparams) == IS_ARRAY && - zend_hash_find(Z_ARRVAL_P(filterparams), "error_mode", sizeof("error_mode"), (void**)&tmpzval) == SUCCESS && + zend_ascii_hash_find(Z_ARRVAL_P(filterparams), "error_mode", sizeof("error_mode"), (void**)&tmpzval) == SUCCESS && tmpzval && *tmpzval) { if (Z_TYPE_PP(tmpzval) == IS_LONG) { err_mode = Z_LVAL_PP(tmpzval); @@ -332,7 +332,7 @@ static php_stream_filter *php_unicode_filter_create(const char *filtername, zval if (filterparams && Z_TYPE_P(filterparams) == IS_ARRAY && - zend_hash_find(Z_ARRVAL_P(filterparams), "subst_char", sizeof("subst_char"), (void**)&tmpzval) == SUCCESS && + zend_ascii_hash_find(Z_ARRVAL_P(filterparams), "subst_char", sizeof("subst_char"), (void**)&tmpzval) == SUCCESS && tmpzval && *tmpzval) { if (Z_TYPE_PP(tmpzval) == IS_UNICODE) { subst_char = Z_USTRVAL_PP(tmpzval); diff --git a/main/streams/userspace.c b/main/streams/userspace.c index 475b680593..9bd290f9ad 100644 --- a/main/streams/userspace.c +++ b/main/streams/userspace.c @@ -787,7 +787,7 @@ static int statbuf_from_array(zval *array, php_stream_statbuf *ssb TSRMLS_DC) zval **elem; #define STAT_PROP_ENTRY_EX(name, name2) \ - if (SUCCESS == zend_hash_find(Z_ARRVAL_P(array), #name, sizeof(#name), (void**)&elem)) { \ + if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(array), #name, sizeof(#name), (void**)&elem)) { \ convert_to_long(*elem); \ ssb->sb.st_##name2 = Z_LVAL_PP(elem); \ } diff --git a/main/streams/xp_socket.c b/main/streams/xp_socket.c index fe6fa16b9f..307399dbe3 100644 --- a/main/streams/xp_socket.c +++ b/main/streams/xp_socket.c @@ -301,9 +301,9 @@ static int php_sockop_set_option(php_stream *stream, int option, int value, void return PHP_STREAM_OPTION_RETURN_OK; case PHP_STREAM_OPTION_META_DATA_API: - add_assoc_bool((zval *)ptrparam, "timed_out", sock->timeout_event); - add_assoc_bool((zval *)ptrparam, "blocked", sock->is_blocked); - add_assoc_bool((zval *)ptrparam, "eof", stream->eof); + add_ascii_assoc_bool((zval *)ptrparam, "timed_out", sock->timeout_event); + add_ascii_assoc_bool((zval *)ptrparam, "blocked", sock->is_blocked); + add_ascii_assoc_bool((zval *)ptrparam, "eof", stream->eof); return PHP_STREAM_OPTION_RETURN_OK; case PHP_STREAM_OPTION_XPORT_API: -- 2.40.0