Merge branch 'master' of git.php.net:php-src

* 'master' of git.php.net:php-src: (1132 commits)
  Micro optimizations for isset/empty
  Micro optimization for zend_hash_next_index_insert_new()
  Fix array_keys() on $GLOBALS
  Fix procedural finfo calls in methods
  Fix allocator for 64bit zend_long with 32bit long
  Use intptr_t for zend_intptr_t typedef
  Fix format strings in zend_alloc
  Drop zend_long64 in favor of int64_t
  Removed deprecated fields
  NEWS
  cleanup NEWS
  removing the NEWS entry as we had to revert this fix for now
  Revert "Merge branch 'PHP-5.5' into PHP-5.6"
  Revert "fix TS build"
  Revert "Merge branch 'PHP-5.4' into PHP-5.5"
  Revert "Bug #67965: Fix blocking behavior in non-blocking crypto streams"
  Revert "Bug #41631: Fix regression from first attempt (6569db8)"
  NEWS
  Fixed Bug #65171 imagescale() fails
  Fixed bug #68234
  ...

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();