diff options
Diffstat (limited to 'Zend/zend_builtin_functions.c')
| -rw-r--r-- | Zend/zend_builtin_functions.c | 385 |
1 files changed, 164 insertions, 221 deletions
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index e89f199b11..9487bb6c1e 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -364,7 +364,7 @@ ZEND_FUNCTION(zend_version) Returns number of freed zvals */ ZEND_FUNCTION(gc_collect_cycles) { - RETURN_INT(gc_collect_cycles(TSRMLS_C)); + RETURN_LONG(gc_collect_cycles(TSRMLS_C)); } /* }}} */ @@ -380,9 +380,9 @@ ZEND_FUNCTION(gc_enabled) Activates the circular reference collector */ ZEND_FUNCTION(gc_enable) { - zend_string *key = STR_INIT("zend.enable_gc", sizeof("zend.enable_gc")-1, 0); - zend_alter_ini_entry(key, "1", sizeof("1")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME); - STR_RELEASE(key); + zend_string *key = zend_string_init("zend.enable_gc", sizeof("zend.enable_gc")-1, 0); + zend_alter_ini_entry_chars(key, "1", sizeof("1")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME); + zend_string_release(key); } /* }}} */ @@ -390,9 +390,9 @@ ZEND_FUNCTION(gc_enable) Deactivates the circular reference collector */ ZEND_FUNCTION(gc_disable) { - zend_string *key = STR_INIT("zend.enable_gc", sizeof("zend.enable_gc")-1, 0); - zend_alter_ini_entry(key, "0", sizeof("0")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME); - STR_RELEASE(key); + zend_string *key = zend_string_init("zend.enable_gc", sizeof("zend.enable_gc")-1, 0); + zend_alter_ini_entry_chars(key, "0", sizeof("0")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME); + zend_string_release(key); } /* }}} */ @@ -400,13 +400,13 @@ ZEND_FUNCTION(gc_disable) Get the number of arguments that were passed to the function */ ZEND_FUNCTION(func_num_args) { - zend_execute_data *ex = EG(current_execute_data)->prev_execute_data; + zend_execute_data *ex = EX(prev_execute_data); - if (ex->frame_kind == VM_FRAME_NESTED_FUNCTION || ex->frame_kind == VM_FRAME_TOP_FUNCTION) { - RETURN_INT(ex->num_args); + if (VM_FRAME_KIND(ex->frame_info) == VM_FRAME_NESTED_FUNCTION || VM_FRAME_KIND(ex->frame_info) == VM_FRAME_TOP_FUNCTION) { + RETURN_LONG(ex->num_args); } else { zend_error(E_WARNING, "func_num_args(): Called from the global scope - no function context"); - RETURN_INT(-1); + RETURN_LONG(-1); } } /* }}} */ @@ -415,12 +415,12 @@ ZEND_FUNCTION(func_num_args) Get the $arg_num'th argument that was passed to the function */ ZEND_FUNCTION(func_get_arg) { - int arg_count, first_extra_arg; + uint32_t arg_count, first_extra_arg; zval *arg; - zend_int_t requested_offset; + zend_long requested_offset; zend_execute_data *ex; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "i", &requested_offset) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &requested_offset) == FAILURE) { return; } @@ -429,8 +429,8 @@ ZEND_FUNCTION(func_get_arg) RETURN_FALSE; } - ex = EG(current_execute_data)->prev_execute_data; - if (ex->frame_kind != VM_FRAME_NESTED_FUNCTION && ex->frame_kind != VM_FRAME_TOP_FUNCTION) { + ex = EX(prev_execute_data); + if (VM_FRAME_KIND(ex->frame_info) != VM_FRAME_NESTED_FUNCTION && VM_FRAME_KIND(ex->frame_info) != VM_FRAME_TOP_FUNCTION) { zend_error(E_WARNING, "func_get_arg(): Called from the global scope - no function context"); RETURN_FALSE; } @@ -438,7 +438,7 @@ ZEND_FUNCTION(func_get_arg) arg_count = ex->num_args; if (requested_offset >= arg_count) { - zend_error(E_WARNING, "func_get_arg(): Argument " ZEND_INT_FMT " not passed to function", requested_offset); + zend_error(E_WARNING, "func_get_arg(): Argument " ZEND_LONG_FMT " not passed to function", requested_offset); RETURN_FALSE; } @@ -460,11 +460,11 @@ ZEND_FUNCTION(func_get_arg) ZEND_FUNCTION(func_get_args) { zval *p; - int arg_count, first_extra_arg; - int i; - zend_execute_data *ex = EG(current_execute_data)->prev_execute_data; + uint32_t arg_count, first_extra_arg; + uint32_t i; + zend_execute_data *ex = EX(prev_execute_data); - if (ex->frame_kind != VM_FRAME_NESTED_FUNCTION && ex->frame_kind != VM_FRAME_TOP_FUNCTION) { + if (VM_FRAME_KIND(ex->frame_info) != VM_FRAME_NESTED_FUNCTION && VM_FRAME_KIND(ex->frame_info) != VM_FRAME_TOP_FUNCTION) { zend_error(E_WARNING, "func_get_args(): Called from the global scope - no function context"); RETURN_FALSE; } @@ -519,7 +519,8 @@ ZEND_FUNCTION(func_get_args) /* }}} */ /* {{{ proto int strlen(string str) - Get string length */ + Get string length + Warning: This function is special-cased by zend_compile.c and so is usually bypassed */ ZEND_FUNCTION(strlen) { zend_string *s; @@ -534,11 +535,10 @@ ZEND_FUNCTION(strlen) ZEND_PARSE_PARAMETERS_END(); #endif - RETVAL_INT(s->len); + RETVAL_LONG(s->len); } /* }}} */ - /* {{{ proto int strcmp(string str1, string str2) Binary safe string comparison */ ZEND_FUNCTION(strcmp) @@ -549,19 +549,18 @@ ZEND_FUNCTION(strcmp) return; } - RETURN_INT(zend_binary_strcmp(s1->val, s1->len, s2->val, s2->len)); + RETURN_LONG(zend_binary_strcmp(s1->val, s1->len, s2->val, s2->len)); } /* }}} */ - /* {{{ proto int strncmp(string str1, string str2, int len) Binary safe string comparison */ ZEND_FUNCTION(strncmp) { zend_string *s1, *s2; - zend_int_t len; + zend_long len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSi", &s1, &s2, &len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSl", &s1, &s2, &len) == FAILURE) { return; } @@ -570,11 +569,10 @@ ZEND_FUNCTION(strncmp) RETURN_FALSE; } - RETURN_INT(zend_binary_strncmp(s1->val, s1->len, s2->val, s2->len, len)); + RETURN_LONG(zend_binary_strncmp(s1->val, s1->len, s2->val, s2->len, len)); } /* }}} */ - /* {{{ proto int strcasecmp(string str1, string str2) Binary safe case-insensitive string comparison */ ZEND_FUNCTION(strcasecmp) @@ -585,19 +583,18 @@ ZEND_FUNCTION(strcasecmp) return; } - RETURN_INT(zend_binary_strcasecmp(s1->val, s1->len, s2->val, s2->len)); + RETURN_LONG(zend_binary_strcasecmp(s1->val, s1->len, s2->val, s2->len)); } /* }}} */ - /* {{{ proto int strncasecmp(string str1, string str2, int len) Binary safe string comparison */ ZEND_FUNCTION(strncasecmp) { zend_string *s1, *s2; - zend_int_t len; + zend_long len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSi", &s1, &s2, &len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSl", &s1, &s2, &len) == FAILURE) { return; } @@ -606,17 +603,16 @@ ZEND_FUNCTION(strncasecmp) RETURN_FALSE; } - RETURN_INT(zend_binary_strncasecmp(s1->val, s1->len, s2->val, s2->len, len)); + RETURN_LONG(zend_binary_strncasecmp(s1->val, s1->len, s2->val, s2->len, len)); } /* }}} */ - /* {{{ proto array each(array arr) Return the currently pointed key..value pair in the passed array, and advance the pointer to the next element */ ZEND_FUNCTION(each) { zval *array, *entry, tmp; - zend_uint_t num_key; + zend_ulong num_key; HashTable *target_hash; zend_string *key; @@ -659,10 +655,10 @@ ZEND_FUNCTION(each) /* add the key elements */ if (zend_hash_get_current_key(target_hash, &key, &num_key, 0) == HASH_KEY_IS_STRING) { - ZVAL_STR(&tmp, STR_COPY(key)); + ZVAL_STR_COPY(&tmp, key); if (Z_REFCOUNTED(tmp)) Z_ADDREF(tmp); } else { - ZVAL_INT(&tmp, num_key); + ZVAL_LONG(&tmp, num_key); } zend_hash_index_add_new(Z_ARRVAL_P(return_value), 0, &tmp); zend_hash_str_add_new(Z_ARRVAL_P(return_value), "key", sizeof("key")-1, &tmp); @@ -670,31 +666,28 @@ ZEND_FUNCTION(each) } /* }}} */ - /* {{{ proto int error_reporting([int new_error_level]) Return the current error_reporting level, and if an argument was passed - change to the new level */ ZEND_FUNCTION(error_reporting) { - char *err; - int err_len; + zend_string *err; int old_error_reporting; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &err, &err_len) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|S", &err) == FAILURE) { return; } old_error_reporting = EG(error_reporting); if(ZEND_NUM_ARGS() != 0) { - zend_string *key = STR_INIT("error_reporting", sizeof("error_reporting")-1, 0); - zend_alter_ini_entry(key, err, err_len, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME); - STR_RELEASE(key); + zend_string *key = zend_string_init("error_reporting", sizeof("error_reporting")-1, 0); + zend_alter_ini_entry(key, err, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME); + zend_string_release(key); } - RETVAL_INT(old_error_reporting); + RETVAL_LONG(old_error_reporting); } /* }}} */ - /* {{{ proto bool define(string constant_name, mixed value, boolean case_insensitive=false) Define a new constant */ ZEND_FUNCTION(define) @@ -732,7 +725,7 @@ ZEND_FUNCTION(define) repeat: switch (Z_TYPE_P(val)) { - case IS_INT: + case IS_LONG: case IS_DOUBLE: case IS_STRING: case IS_FALSE: @@ -764,7 +757,7 @@ repeat: ZVAL_DUP(&c.value, val); zval_ptr_dtor(&val_free); c.flags = case_sensitive; /* non persistent */ - c.name = STR_COPY(name); + c.name = zend_string_copy(name); c.module_number = PHP_USER_CONSTANT; if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) { RETURN_TRUE; @@ -774,9 +767,9 @@ repeat: } /* }}} */ - /* {{{ proto bool defined(string constant_name) - Check whether a constant exists */ + Check whether a constant exists + Warning: This function is special-cased by zend_compile.c and so is usually bypassed */ ZEND_FUNCTION(defined) { zend_string *name; @@ -799,7 +792,6 @@ ZEND_FUNCTION(defined) } /* }}} */ - /* {{{ proto string get_class([object object]) Retrieves the class name */ ZEND_FUNCTION(get_class) @@ -812,18 +804,17 @@ ZEND_FUNCTION(get_class) if (!obj) { if (EG(scope)) { - RETURN_STR(STR_COPY(EG(scope)->name)); + RETURN_STR(zend_string_copy(EG(scope)->name)); } else { zend_error(E_WARNING, "get_class() called without object from outside a class"); RETURN_FALSE; } } - RETURN_STR(zend_get_object_classname(Z_OBJ_P(obj) TSRMLS_CC)); + RETURN_STR(zend_string_copy(Z_OBJCE_P(obj)->name)); } /* }}} */ - /* {{{ proto string get_called_class() Retrieves the "Late Static Binding" class name */ ZEND_FUNCTION(get_called_class) @@ -832,8 +823,8 @@ ZEND_FUNCTION(get_called_class) return; } - if (EG(current_execute_data)->called_scope) { - RETURN_STR(STR_COPY(EG(current_execute_data)->called_scope->name)); + if (EX(called_scope)) { + RETURN_STR(zend_string_copy(EX(called_scope)->name)); } else if (!EG(scope)) { zend_error(E_WARNING, "get_called_class() called from outside a class"); } @@ -841,14 +832,12 @@ ZEND_FUNCTION(get_called_class) } /* }}} */ - /* {{{ proto string get_parent_class([mixed object]) Retrieves the parent class name for object or class or current scope. */ ZEND_FUNCTION(get_parent_class) { zval *arg; zend_class_entry *ce = NULL; - zend_string *name; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) { return; @@ -857,33 +846,27 @@ ZEND_FUNCTION(get_parent_class) if (!ZEND_NUM_ARGS()) { ce = EG(scope); if (ce && ce->parent) { - RETURN_STR(STR_COPY(ce->parent->name)); + RETURN_STR(zend_string_copy(ce->parent->name)); } else { RETURN_FALSE; } } if (Z_TYPE_P(arg) == IS_OBJECT) { - if (Z_OBJ_HT_P(arg)->get_class_name - && (name = Z_OBJ_HT_P(arg)->get_class_name(Z_OBJ_P(arg), 1 TSRMLS_CC)) != NULL) { - RETURN_STR(name); - } else { - ce = zend_get_class_entry(Z_OBJ_P(arg) TSRMLS_CC); - } + ce = Z_OBJ_P(arg)->ce; } else if (Z_TYPE_P(arg) == IS_STRING) { ce = zend_lookup_class(Z_STR_P(arg) TSRMLS_CC); } if (ce && ce->parent) { - RETURN_STR(STR_COPY(ce->parent->name)); + RETURN_STR(zend_string_copy(ce->parent->name)); } else { RETURN_FALSE; } } /* }}} */ - -static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass) +static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass) /* {{{ */ { zval *obj; zend_string *class_name; @@ -916,7 +899,7 @@ static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass) if (!instance_ce) { RETURN_FALSE; } - } else if (Z_TYPE_P(obj) == IS_OBJECT && HAS_CLASS_ENTRY(*obj)) { + } else if (Z_TYPE_P(obj) == IS_OBJECT) { instance_ce = Z_OBJCE_P(obj); } else { RETURN_FALSE; @@ -935,7 +918,7 @@ static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass) RETURN_BOOL(retval); } - +/* }}} */ /* {{{ proto bool is_subclass_of(mixed object_or_string, string class_name [, bool allow_string=true]) Returns true if the object has this class as one of its parents */ @@ -945,7 +928,6 @@ ZEND_FUNCTION(is_subclass_of) } /* }}} */ - /* {{{ proto bool is_a(mixed object_or_string, string class_name [, bool allow_string=false]) Returns true if the first argument is an object and is this class or has this class as one of its parents, */ ZEND_FUNCTION(is_a) @@ -954,7 +936,6 @@ ZEND_FUNCTION(is_a) } /* }}} */ - /* {{{ add_class_vars */ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value TSRMLS_DC) { @@ -1002,7 +983,6 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value } /* }}} */ - /* {{{ proto array get_class_vars(string class_name) Returns an array of default properties of the class. */ ZEND_FUNCTION(get_class_vars) @@ -1026,7 +1006,6 @@ ZEND_FUNCTION(get_class_vars) } /* }}} */ - /* {{{ proto array get_object_vars(object obj) Returns an array of object properties */ ZEND_FUNCTION(get_object_vars) @@ -1035,8 +1014,6 @@ ZEND_FUNCTION(get_object_vars) zval *value; HashTable *properties; zend_string *key; - const char *prop_name, *class_name; - uint prop_len; zend_object *zobj; #ifndef FAST_ZPP @@ -1061,7 +1038,7 @@ ZEND_FUNCTION(get_object_vars) zobj = Z_OBJ_P(obj); - array_init(return_value); + array_init_size(return_value, zend_hash_num_elements(properties)); ZEND_HASH_FOREACH_STR_KEY_VAL_IND(properties, key, value) { if (key) { @@ -1069,7 +1046,9 @@ ZEND_FUNCTION(get_object_vars) /* Not separating references */ if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); if (key->val[0] == 0) { - zend_unmangle_property_name_ex(key->val, key->len, &class_name, &prop_name, (int*) &prop_len); + const char *prop_name, *class_name; + size_t prop_len; + zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_len); zend_hash_str_add_new(Z_ARRVAL_P(return_value), prop_name, prop_len, value); } else { zend_hash_add_new(Z_ARRVAL_P(return_value), key, value); @@ -1080,13 +1059,14 @@ ZEND_FUNCTION(get_object_vars) } /* }}} */ -static int same_name(const char *key, const char *name, zend_uint name_len) +static int same_name(const char *key, const char *name, uint32_t name_len) /* {{{ */ { char *lcname = zend_str_tolower_dup(name, name_len); int ret = memcmp(lcname, key, name_len) == 0; efree(lcname); return ret; } +/* }}} */ /* {{{ proto array get_class_methods(mixed class) Returns an array of method names for class or class instance. */ @@ -1103,10 +1083,6 @@ ZEND_FUNCTION(get_class_methods) } if (Z_TYPE_P(klass) == IS_OBJECT) { - /* TBI!! new object handlers */ - if (!HAS_CLASS_ENTRY(*klass)) { - RETURN_FALSE; - } ce = Z_OBJCE_P(klass); } else if (Z_TYPE_P(klass) == IS_STRING) { ce = zend_lookup_class(Z_STR_P(klass) TSRMLS_CC); @@ -1130,7 +1106,7 @@ ZEND_FUNCTION(get_class_methods) /* Do not display old-style inherited constructors */ if (!key) { - ZVAL_STR(&method_name, STR_COPY(mptr->common.function_name)); + ZVAL_STR_COPY(&method_name, mptr->common.function_name); zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &method_name); } else if ((mptr->common.fn_flags & ZEND_ACC_CTOR) == 0 || mptr->common.scope == ce || @@ -1140,10 +1116,10 @@ ZEND_FUNCTION(get_class_methods) *mptr->op_array.refcount > 1 && (len != key->len || !same_name(key->val, mptr->common.function_name->val, len))) { - ZVAL_STR(&method_name, STR_COPY(zend_find_alias_name(mptr->common.scope, key))); + ZVAL_STR_COPY(&method_name, zend_find_alias_name(mptr->common.scope, key)); zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &method_name); } else { - ZVAL_STR(&method_name, STR_COPY(mptr->common.function_name)); + ZVAL_STR_COPY(&method_name, mptr->common.function_name); zend_hash_next_index_insert_new(Z_ARRVAL_P(return_value), &method_name); } } @@ -1152,7 +1128,6 @@ ZEND_FUNCTION(get_class_methods) } /* }}} */ - /* {{{ proto bool method_exists(object object, string method) Checks if the class method exists */ ZEND_FUNCTION(method_exists) @@ -1182,10 +1157,10 @@ ZEND_FUNCTION(method_exists) RETURN_FALSE; } - lcname = STR_ALLOC(method_name->len, 0); + lcname = zend_string_alloc(method_name->len, 0); zend_str_tolower_copy(lcname->val, method_name->val, method_name->len); if (zend_hash_exists(&ce->function_table, lcname)) { - STR_FREE(lcname); + zend_string_free(lcname); RETURN_TRUE; } else { union _zend_function *func = NULL; @@ -1198,12 +1173,11 @@ ZEND_FUNCTION(method_exists) && (func->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0 ) { /* Returns true to the fake Closure's __invoke */ - RETVAL_BOOL((func->common.scope == zend_ce_closure - && (method_name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) - && memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0) ? 1 : 0); + RETVAL_BOOL(func->common.scope == zend_ce_closure + && zend_string_equals_literal(method_name, ZEND_INVOKE_FUNC_NAME)); - STR_FREE(lcname); - STR_RELEASE(func->common.function_name); + zend_string_free(lcname); + zend_string_release(func->common.function_name); efree(func); return; } @@ -1262,7 +1236,6 @@ ZEND_FUNCTION(property_exists) } /* }}} */ - /* {{{ proto bool class_exists(string classname [, bool autoload]) Checks if the class exists */ ZEND_FUNCTION(class_exists) @@ -1287,14 +1260,14 @@ ZEND_FUNCTION(class_exists) if (!autoload) { if (class_name->val[0] == '\\') { /* Ignore leading "\" */ - lc_name = STR_ALLOC(class_name->len - 1, 0); + lc_name = zend_string_alloc(class_name->len - 1, 0); zend_str_tolower_copy(lc_name->val, class_name->val + 1, class_name->len - 1); } else { - lc_name = STR_ALLOC(class_name->len, 0); + lc_name = zend_string_alloc(class_name->len, 0); zend_str_tolower_copy(lc_name->val, class_name->val, class_name->len); } ce = zend_hash_find_ptr(EG(class_table), lc_name); - STR_FREE(lc_name); + zend_string_free(lc_name); RETURN_BOOL(ce && !((ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT)) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)); } @@ -1330,14 +1303,14 @@ ZEND_FUNCTION(interface_exists) if (!autoload) { if (iface_name->val[0] == '\\') { /* Ignore leading "\" */ - lc_name = STR_ALLOC(iface_name->len - 1, 0); + lc_name = zend_string_alloc(iface_name->len - 1, 0); zend_str_tolower_copy(lc_name->val, iface_name->val + 1, iface_name->len - 1); } else { - lc_name = STR_ALLOC(iface_name->len, 0); + lc_name = zend_string_alloc(iface_name->len, 0); zend_str_tolower_copy(lc_name->val, iface_name->val, iface_name->len); } ce = zend_hash_find_ptr(EG(class_table), lc_name); - STR_FREE(lc_name); + zend_string_free(lc_name); RETURN_BOOL(ce && ce->ce_flags & ZEND_ACC_INTERFACE); } @@ -1373,14 +1346,14 @@ ZEND_FUNCTION(trait_exists) if (!autoload) { if (trait_name->val[0] == '\\') { /* Ignore leading "\" */ - lc_name = STR_ALLOC(trait_name->len - 1, 0); + lc_name = zend_string_alloc(trait_name->len - 1, 0); zend_str_tolower_copy(lc_name->val, trait_name->val + 1, trait_name->len - 1); } else { - lc_name = STR_ALLOC(trait_name->len, 0); + lc_name = zend_string_alloc(trait_name->len, 0); zend_str_tolower_copy(lc_name->val, trait_name->val, trait_name->len); } ce = zend_hash_find_ptr(EG(class_table), lc_name); - STR_FREE(lc_name); + zend_string_free(lc_name); RETURN_BOOL(ce && ((ce->ce_flags & ZEND_ACC_TRAIT) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)); } @@ -1393,13 +1366,12 @@ ZEND_FUNCTION(trait_exists) } /* }}} */ - /* {{{ proto bool function_exists(string function_name) Checks if the function exists */ ZEND_FUNCTION(function_exists) { char *name; - int name_len; + size_t name_len; zend_function *func; zend_string *lcname; @@ -1415,15 +1387,15 @@ ZEND_FUNCTION(function_exists) if (name[0] == '\\') { /* Ignore leading "\" */ - lcname = STR_ALLOC(name_len - 1, 0); + lcname = zend_string_alloc(name_len - 1, 0); zend_str_tolower_copy(lcname->val, name + 1, name_len - 1); } else { - lcname = STR_ALLOC(name_len, 0); + lcname = zend_string_alloc(name_len, 0); zend_str_tolower_copy(lcname->val, name, name_len); } func = zend_hash_find_ptr(EG(function_table), lcname); - STR_FREE(lcname); + zend_string_free(lcname); /* * A bit of a hack, but not a bad one: we see if the handler of the function @@ -1441,7 +1413,7 @@ ZEND_FUNCTION(class_alias) zend_string *class_name; char *alias_name; zend_class_entry *ce; - int alias_name_len; + size_t alias_name_len; zend_bool autoload = 1; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|b", &class_name, &alias_name, &alias_name_len, &autoload) == FAILURE) { @@ -1474,9 +1446,9 @@ ZEND_FUNCTION(class_alias) Cause an intentional memory leak, for testing/debugging purposes */ ZEND_FUNCTION(leak) { - zend_int_t leakbytes=3; + zend_long leakbytes=3; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|i", &leakbytes) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &leakbytes) == FAILURE) { return; } @@ -1531,22 +1503,21 @@ ZEND_FUNCTION(get_included_files) array_init(return_value); ZEND_HASH_FOREACH_STR_KEY(&EG(included_files), entry) { if (entry) { - add_next_index_str(return_value, STR_COPY(entry)); + add_next_index_str(return_value, zend_string_copy(entry)); } } ZEND_HASH_FOREACH_END(); } /* }}} */ - /* {{{ proto void trigger_error(string message [, int error_type]) Generates a user-level error/warning/notice message */ ZEND_FUNCTION(trigger_error) { - zend_int_t error_type = E_USER_NOTICE; + zend_long error_type = E_USER_NOTICE; char *message; - int message_len; + size_t message_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|i", &message, &message_len, &error_type) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &message, &message_len, &error_type) == FAILURE) { return; } @@ -1567,16 +1538,15 @@ ZEND_FUNCTION(trigger_error) } /* }}} */ - /* {{{ proto string set_error_handler(string error_handler [, int error_types]) Sets a user-defined error handler function. Returns the previously defined error handler, or false on error */ ZEND_FUNCTION(set_error_handler) { zval *error_handler; zend_string *error_handler_name = NULL; - zend_int_t error_type = E_ALL; + zend_long error_type = E_ALL; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|i", &error_handler, &error_type) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) { return; } @@ -1584,10 +1554,10 @@ ZEND_FUNCTION(set_error_handler) if (!zend_is_callable(error_handler, 0, &error_handler_name TSRMLS_CC)) { zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback", get_active_function_name(TSRMLS_C), error_handler_name?error_handler_name->val:"unknown"); - STR_RELEASE(error_handler_name); + zend_string_release(error_handler_name); return; } - STR_RELEASE(error_handler_name); + zend_string_release(error_handler_name); } if (Z_TYPE(EG(user_error_handler)) != IS_UNDEF) { @@ -1607,7 +1577,6 @@ ZEND_FUNCTION(set_error_handler) } /* }}} */ - /* {{{ proto void restore_error_handler(void) Restores the previously defined error handler function */ ZEND_FUNCTION(restore_error_handler) @@ -1634,7 +1603,6 @@ ZEND_FUNCTION(restore_error_handler) } /* }}} */ - /* {{{ proto string set_exception_handler(callable exception_handler) Sets a user-defined exception handler function. Returns the previously defined exception handler, or false on error */ ZEND_FUNCTION(set_exception_handler) @@ -1650,10 +1618,10 @@ ZEND_FUNCTION(set_exception_handler) if (!zend_is_callable(exception_handler, 0, &exception_handler_name TSRMLS_CC)) { zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback", get_active_function_name(TSRMLS_C), exception_handler_name?exception_handler_name->val:"unknown"); - STR_RELEASE(exception_handler_name); + zend_string_release(exception_handler_name); return; } - STR_RELEASE(exception_handler_name); + zend_string_release(exception_handler_name); } if (Z_TYPE(EG(user_exception_handler)) != IS_UNDEF) { @@ -1671,7 +1639,6 @@ ZEND_FUNCTION(set_exception_handler) } /* }}} */ - /* {{{ proto void restore_exception_handler(void) Restores the previously defined exception handler function */ ZEND_FUNCTION(restore_exception_handler) @@ -1690,33 +1657,34 @@ ZEND_FUNCTION(restore_exception_handler) } /* }}} */ -static int copy_class_or_interface_name(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) +static int copy_class_or_interface_name(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ { zend_class_entry *ce = (zend_class_entry *)Z_PTR_P(el); zval *array = va_arg(args, zval *); - zend_uint mask = va_arg(args, zend_uint); - zend_uint comply = va_arg(args, zend_uint); - zend_uint comply_mask = (comply)? mask:0; + uint32_t mask = va_arg(args, uint32_t); + uint32_t comply = va_arg(args, uint32_t); + uint32_t comply_mask = (comply)? mask:0; if ((hash_key->key && hash_key->key->val[0] != 0) && (comply_mask == (ce->ce_flags & mask))) { if (ce->refcount > 1 && (ce->name->len != hash_key->key->len || !same_name(hash_key->key->val, ce->name->val, ce->name->len))) { - add_next_index_str(array, STR_COPY(hash_key->key)); + add_next_index_str(array, zend_string_copy(hash_key->key)); } else { - add_next_index_str(array, STR_COPY(ce->name)); + add_next_index_str(array, zend_string_copy(ce->name)); } } return ZEND_HASH_APPLY_KEEP; } +/* }}} */ /* {{{ proto array get_declared_traits() Returns an array of all declared traits. */ ZEND_FUNCTION(get_declared_traits) { - zend_uint mask = ZEND_ACC_TRAIT; - zend_uint comply = 1; + uint32_t mask = ZEND_ACC_TRAIT; + uint32_t comply = 1; if (zend_parse_parameters_none() == FAILURE) { return; @@ -1727,13 +1695,12 @@ ZEND_FUNCTION(get_declared_traits) } /* }}} */ - /* {{{ proto array get_declared_classes() Returns an array of all declared classes. */ ZEND_FUNCTION(get_declared_classes) { - zend_uint mask = ZEND_ACC_INTERFACE | (ZEND_ACC_TRAIT & ~ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); - zend_uint comply = 0; + uint32_t mask = ZEND_ACC_INTERFACE | (ZEND_ACC_TRAIT & ~ZEND_ACC_EXPLICIT_ABSTRACT_CLASS); + uint32_t comply = 0; if (zend_parse_parameters_none() == FAILURE) { return; @@ -1748,8 +1715,8 @@ ZEND_FUNCTION(get_declared_classes) Returns an array of all declared interfaces. */ ZEND_FUNCTION(get_declared_interfaces) { - zend_uint mask = ZEND_ACC_INTERFACE; - zend_uint comply = 1; + uint32_t mask = ZEND_ACC_INTERFACE; + uint32_t comply = 1; if (zend_parse_parameters_none() == FAILURE) { return; @@ -1760,8 +1727,7 @@ ZEND_FUNCTION(get_declared_interfaces) } /* }}} */ - -static int copy_function_name(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) +static int copy_function_name(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ { zend_function *func = Z_PTR_P(zv); zval *internal_ar = va_arg(args, zval *), @@ -1772,20 +1738,20 @@ static int copy_function_name(zval *zv TSRMLS_DC, int num_args, va_list args, ze } if (func->type == ZEND_INTERNAL_FUNCTION) { - add_next_index_str(internal_ar, STR_COPY(hash_key->key)); + add_next_index_str(internal_ar, zend_string_copy(hash_key->key)); } else if (func->type == ZEND_USER_FUNCTION) { - add_next_index_str(user_ar, STR_COPY(hash_key->key)); + add_next_index_str(user_ar, zend_string_copy(hash_key->key)); } return 0; } - +/* }}} */ /* {{{ proto array get_defined_functions(void) Returns an array of all defined functions */ ZEND_FUNCTION(get_defined_functions) { - zval internal, user, *ret; + zval internal, user; if (zend_parse_parameters_none() == FAILURE) { return; @@ -1797,27 +1763,11 @@ ZEND_FUNCTION(get_defined_functions) zend_hash_apply_with_arguments(EG(function_table) TSRMLS_CC, copy_function_name, 2, &internal, &user); - ret = zend_hash_str_add_new(Z_ARRVAL_P(return_value), "internal", sizeof("internal")-1, &internal); - - if (!ret) { - zval_ptr_dtor(&internal); - zval_ptr_dtor(&user); - zval_dtor(return_value); - zend_error(E_WARNING, "Cannot add internal functions to return value from get_defined_functions()"); - RETURN_FALSE; - } - - ret = zend_hash_str_add_new(Z_ARRVAL_P(return_value), "user", sizeof("user")-1, &user); - if (!ret) { - zval_ptr_dtor(&user); - zval_dtor(return_value); - zend_error(E_WARNING, "Cannot add user functions to return value from get_defined_functions()"); - RETURN_FALSE; - } + zend_hash_str_add_new(Z_ARRVAL_P(return_value), "internal", sizeof("internal")-1, &internal); + zend_hash_str_add_new(Z_ARRVAL_P(return_value), "user", sizeof("user")-1, &user); } /* }}} */ - /* {{{ proto array get_defined_vars(void) Returns an associative array of names and values of all currently defined variable names (variables in the current scope) */ ZEND_FUNCTION(get_defined_vars) @@ -1829,7 +1779,6 @@ ZEND_FUNCTION(get_defined_vars) } /* }}} */ - #define LAMBDA_TEMP_FUNCNAME "__lambda_func" /* {{{ proto string create_function(string args, string code) Creates an anonymous function, and returns its name (funny, eh?) */ @@ -1837,7 +1786,7 @@ ZEND_FUNCTION(create_function) { zend_string *function_name; char *eval_code, *function_args, *function_code; - int eval_code_length, function_args_len, function_code_len; + size_t eval_code_length, function_args_len, function_code_len; int retval; char *eval_name; @@ -1882,11 +1831,11 @@ ZEND_FUNCTION(create_function) } (*func->refcount)++; - function_name = STR_ALLOC(sizeof("0lambda_")+MAX_LENGTH_OF_ZEND_INT, 0); + function_name = zend_string_alloc(sizeof("0lambda_")+MAX_LENGTH_OF_LONG, 0); function_name->val[0] = '\0'; do { - function_name->len = snprintf(function_name->val + 1, sizeof("lambda_")+MAX_LENGTH_OF_ZEND_INT, "lambda_%d", ++EG(lambda_count)) + 1; + function_name->len = snprintf(function_name->val + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count)) + 1; } while (zend_hash_add_ptr(EG(function_table), function_name, func) == NULL); static_variables = func->static_variables; func->static_variables = NULL; @@ -1900,7 +1849,6 @@ ZEND_FUNCTION(create_function) } /* }}} */ - #if ZEND_DEBUG ZEND_FUNCTION(zend_test_func) { @@ -1913,7 +1861,7 @@ ZEND_FUNCTION(zend_test_func) #ifdef ZTS ZEND_FUNCTION(zend_thread_id) { - RETURN_INT((zend_int_t)tsrm_thread_id()); + RETURN_LONG((zend_long)tsrm_thread_id()); } #endif #endif @@ -1944,7 +1892,7 @@ ZEND_FUNCTION(get_resources) { zend_string *type = NULL; zend_string *key; - zend_uint_t index; + zend_ulong index; zval *val; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|S", &type) == FAILURE) { @@ -1959,8 +1907,7 @@ ZEND_FUNCTION(get_resources) zend_hash_index_add_new(Z_ARRVAL_P(return_value), index, val); } } ZEND_HASH_FOREACH_END(); - } else if (type->len == sizeof("Unknown")-1 && - memcmp(type->val, "Unknown", sizeof("Unknown")-1) == 0) { + } else if (zend_string_equals_literal(type, "Unknown")) { array_init(return_value); ZEND_HASH_FOREACH_KEY_VAL(&EG(regular_list), index, key, val) { if (!key && Z_RES_TYPE_P(val) <= 0) { @@ -1987,22 +1934,24 @@ ZEND_FUNCTION(get_resources) } /* }}} */ -static int add_extension_info(zval *item, void *arg TSRMLS_DC) +static int add_extension_info(zval *item, void *arg TSRMLS_DC) /* {{{ */ { zval *name_array = (zval *)arg; zend_module_entry *module = (zend_module_entry*)Z_PTR_P(item); add_next_index_string(name_array, module->name); return 0; } +/* }}} */ -static int add_zendext_info(zend_extension *ext, void *arg TSRMLS_DC) +static int add_zendext_info(zend_extension *ext, void *arg TSRMLS_DC) /* {{{ */ { zval *name_array = (zval *)arg; add_next_index_string(name_array, ext->name); return 0; } +/* }}} */ -static int add_constant_info(zval *item, void *arg TSRMLS_DC) +static int add_constant_info(zval *item, void *arg TSRMLS_DC) /* {{{ */ { zval *name_array = (zval *)arg; zend_constant *constant = (zend_constant*)Z_PTR_P(item); @@ -2017,7 +1966,7 @@ static int add_constant_info(zval *item, void *arg TSRMLS_DC) zend_hash_add_new(Z_ARRVAL_P(name_array), constant->name, &const_val); return 0; } - +/* }}} */ /* {{{ proto array get_loaded_extensions([bool zend_extensions]) U Return an array containing names of loaded extensions */ @@ -2039,7 +1988,6 @@ ZEND_FUNCTION(get_loaded_extensions) } /* }}} */ - /* {{{ proto array get_defined_constants([bool categorize]) Return an array containing the names and values of all defined constants */ ZEND_FUNCTION(get_defined_constants) @@ -2102,18 +2050,17 @@ ZEND_FUNCTION(get_defined_constants) } /* }}} */ - -static void debug_backtrace_get_args(zend_execute_data *call, zval *arg_array TSRMLS_DC) +static void debug_backtrace_get_args(zend_execute_data *call, zval *arg_array TSRMLS_DC) /* {{{ */ { - int num_args = call->num_args; + uint32_t num_args = call->num_args; array_init_size(arg_array, num_args); if (num_args) { - int i = 0; + uint32_t i = 0; zval *p = ZEND_CALL_ARG(call, 1); if (call->func->type == ZEND_USER_FUNCTION) { - int first_extra_arg = call->func->op_array.num_args; + uint32_t first_extra_arg = call->func->op_array.num_args; if (call->func->op_array.fn_flags & ZEND_ACC_VARIADIC) { first_extra_arg--; @@ -2137,8 +2084,9 @@ static void debug_backtrace_get_args(zend_execute_data *call, zval *arg_array TS } } } +/* }}} */ -void debug_print_backtrace_args(zval *arg_array TSRMLS_DC) +void debug_print_backtrace_args(zval *arg_array TSRMLS_DC) /* {{{ */ { zval *tmp; int i = 0; @@ -2150,6 +2098,7 @@ void debug_print_backtrace_args(zval *arg_array TSRMLS_DC) zend_print_flat_zval_r(tmp TSRMLS_CC); } ZEND_HASH_FOREACH_END(); } +/* }}} */ /* {{{ proto void debug_print_backtrace([int options[, int limit]]) */ ZEND_FUNCTION(debug_print_backtrace) @@ -2165,15 +2114,15 @@ ZEND_FUNCTION(debug_print_backtrace) const char *include_filename = NULL; zval arg_array; int indent = 0; - zend_int_t options = 0; - zend_int_t limit = 0; + zend_long options = 0; + zend_long limit = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ii", &options, &limit) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) { return; } ZVAL_UNDEF(&arg_array); - ptr = EG(current_execute_data)->prev_execute_data; + ptr = EX(prev_execute_data); /* skip debug_backtrace() */ call = ptr; @@ -2213,7 +2162,7 @@ ZEND_FUNCTION(debug_print_backtrace) } /* $this may be passed into regular internal functions */ - object = call->object; + object = Z_OBJ(call->This); if (object && call && call->func->type == ZEND_INTERNAL_FUNCTION && @@ -2226,9 +2175,7 @@ ZEND_FUNCTION(debug_print_backtrace) function_name = (func->common.scope && func->common.scope->trait_aliases) ? zend_resolve_method_name( - (object ? - zend_get_class_entry(object TSRMLS_CC) : - func->common.scope), func)->val : + (object ? object->ce : func->common.scope), func)->val : (func->common.function_name ? func->common.function_name->val : NULL); } else { @@ -2241,7 +2188,7 @@ ZEND_FUNCTION(debug_print_backtrace) if (func->common.scope) { class_name = func->common.scope->name; } else { - class_name = zend_get_object_classname(object TSRMLS_CC); + class_name = object->ce->name; } call_type = "->"; @@ -2340,7 +2287,7 @@ ZEND_FUNCTION(debug_print_backtrace) /* }}} */ -ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int options, int limit TSRMLS_DC) +ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int options, int limit TSRMLS_DC) /* {{{ */ { zend_execute_data *call, *ptr, *skip; zend_object *object; @@ -2348,7 +2295,6 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int zend_function *func; const char *function_name; const char *filename; - zend_string *class_name; const char *include_filename = NULL; zval stack_frame; @@ -2406,7 +2352,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int lineno = skip->opline->lineno; } add_assoc_string_ex(&stack_frame, "file", sizeof("file")-1, (char*)filename); - add_assoc_int_ex(&stack_frame, "line", sizeof("line")-1, lineno); + add_assoc_long_ex(&stack_frame, "line", sizeof("line")-1, 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 @@ -2424,8 +2370,8 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int break; } if (prev->func && ZEND_USER_CODE(prev->func->common.type)) { - add_assoc_str_ex(&stack_frame, "file", sizeof("file")-1, STR_COPY(prev->func->op_array.filename)); - add_assoc_int_ex(&stack_frame, "line", sizeof("line")-1, prev->opline->lineno); + add_assoc_str_ex(&stack_frame, "file", sizeof("file")-1, zend_string_copy(prev->func->op_array.filename)); + add_assoc_long_ex(&stack_frame, "line", sizeof("line")-1, prev->opline->lineno); break; } prev_call = prev; @@ -2435,8 +2381,9 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int } /* $this may be passed into regular internal functions */ - object = call ? call->object : NULL; + object = call ? Z_OBJ(call->This) : NULL; if (object && + call->func && call->func->type == ZEND_INTERNAL_FUNCTION && !call->func->common.scope) { object = NULL; @@ -2447,9 +2394,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int function_name = (func->common.scope && func->common.scope->trait_aliases) ? zend_resolve_method_name( - (object ? - zend_get_class_entry(object TSRMLS_CC) : - func->common.scope), func)->val : + (object ? object->ce : func->common.scope), func)->val : (func->common.function_name ? func->common.function_name->val : NULL); } else { @@ -2462,10 +2407,9 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int if (object) { if (func->common.scope) { - add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(func->common.scope->name)); + add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, zend_string_copy(func->common.scope->name)); } else { - class_name = zend_get_object_classname(object TSRMLS_CC); - add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(class_name)); + add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, zend_string_copy(object->ce->name)); } if ((options & DEBUG_BACKTRACE_PROVIDE_OBJECT) != 0) { @@ -2477,7 +2421,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "->"); } else if (func->common.scope) { - add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(func->common.scope->name)); + add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, zend_string_copy(func->common.scope->name)); add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "::"); } @@ -2548,15 +2492,14 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int } /* }}} */ - /* {{{ proto array debug_backtrace([int options[, int limit]]) Return backtrace as array */ ZEND_FUNCTION(debug_backtrace) { - zend_int_t options = DEBUG_BACKTRACE_PROVIDE_OBJECT; - zend_int_t limit = 0; + zend_long options = DEBUG_BACKTRACE_PROVIDE_OBJECT; + zend_long limit = 0; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ii", &options, &limit) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ll", &options, &limit) == FAILURE) { return; } @@ -2569,32 +2512,32 @@ ZEND_FUNCTION(debug_backtrace) ZEND_FUNCTION(extension_loaded) { char *extension_name; - int extension_name_len; + size_t extension_name_len; zend_string *lcname; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) { return; } - lcname = STR_ALLOC(extension_name_len, 0); + lcname = zend_string_alloc(extension_name_len, 0); zend_str_tolower_copy(lcname->val, extension_name, extension_name_len); if (zend_hash_exists(&module_registry, lcname)) { RETVAL_TRUE; } else { RETVAL_FALSE; } - STR_FREE(lcname); + zend_string_free(lcname); } /* }}} */ - /* {{{ proto array get_extension_funcs(string extension_name) Returns an array with the names of functions belonging to the named extension */ ZEND_FUNCTION(get_extension_funcs) { char *extension_name; zend_string *lcname; - int extension_name_len, array; + size_t extension_name_len; + int array; zend_module_entry *module; zend_function *zif; @@ -2602,13 +2545,13 @@ ZEND_FUNCTION(get_extension_funcs) return; } if (strncasecmp(extension_name, "zend", sizeof("zend"))) { - lcname = STR_ALLOC(extension_name_len, 0); + lcname = zend_string_alloc(extension_name_len, 0); zend_str_tolower_copy(lcname->val, extension_name, extension_name_len); } else { - lcname = STR_INIT("core", sizeof("core")-1, 0); + lcname = zend_string_init("core", sizeof("core")-1, 0); } module = zend_hash_find_ptr(&module_registry, lcname); - STR_FREE(lcname); + zend_string_free(lcname); if (!module) { RETURN_FALSE; } @@ -2628,7 +2571,7 @@ ZEND_FUNCTION(get_extension_funcs) array_init(return_value); array = 1; } - add_next_index_str(return_value, STR_COPY(zif->common.function_name)); + add_next_index_str(return_value, zend_string_copy(zif->common.function_name)); } } ZEND_HASH_FOREACH_END(); |