Merge remote-tracking branch 'origin/native-tls'POST_NATIVE_TLS_MERGE

7 files changed, 119 insertions, 119 deletions

diff --git a/ext/intl/breakiterator/breakiterator_class.cpp b/ext/intl/breakiterator/breakiterator_class.cpp
index 715a866111..813204cd21 100644
--- a/ext/intl/breakiterator/breakiterator_class.cpp
+++ b/ext/intl/breakiterator/breakiterator_class.cpp
@@ -47,7 +47,7 @@ zend_object_handlers BreakIterator_handlers;
 /* }}} */
 
 U_CFUNC	void breakiterator_object_create(zval *object,
-										 BreakIterator *biter, int brand_new TSRMLS_DC)
+										 BreakIterator *biter, int brand_new)
 {
 	UClassID classId = biter->getDynamicClassID();
 	zend_class_entry *ce;
@@ -63,11 +63,11 @@ U_CFUNC	void breakiterator_object_create(zval *object,
 	if (brand_new) {
 		object_init_ex(object, ce);
 	}
-	breakiterator_object_construct(object, biter TSRMLS_CC);
+	breakiterator_object_construct(object, biter);
 }
 
 U_CFUNC void breakiterator_object_construct(zval *object,
-											BreakIterator *biter TSRMLS_DC)
+											BreakIterator *biter)
 {
 	BreakIterator_object *bio;
 
@@ -78,7 +78,7 @@ U_CFUNC void breakiterator_object_construct(zval *object,
 
 /* {{{ compare handler for BreakIterator */
 static int BreakIterator_compare_objects(zval *object1,
-										 zval *object2 TSRMLS_DC)
+										 zval *object2)
 {
 	BreakIterator_object	*bio1,
 							*bio2;
@@ -95,19 +95,19 @@ static int BreakIterator_compare_objects(zval *object1,
 /* }}} */
 
 /* {{{ clone handler for BreakIterator */
-static zend_object *BreakIterator_clone_obj(zval *object TSRMLS_DC)
+static zend_object *BreakIterator_clone_obj(zval *object)
 {
 	BreakIterator_object	*bio_orig,
 							*bio_new;
 	zend_object				*ret_val;
 
 	bio_orig = Z_INTL_BREAKITERATOR_P(object);
-	intl_errors_reset(INTL_DATA_ERROR_P(bio_orig) TSRMLS_CC);
+	intl_errors_reset(INTL_DATA_ERROR_P(bio_orig));
 
-	ret_val = BreakIterator_ce_ptr->create_object(Z_OBJCE_P(object) TSRMLS_CC);
+	ret_val = BreakIterator_ce_ptr->create_object(Z_OBJCE_P(object));
 	bio_new  = php_intl_breakiterator_fetch_object(ret_val);
 
-	zend_objects_clone_members(&bio_new->zo, &bio_orig->zo TSRMLS_CC);
+	zend_objects_clone_members(&bio_new->zo, &bio_orig->zo);
 
 	if (bio_orig->biter != NULL) {
 		BreakIterator *new_biter;
@@ -116,18 +116,18 @@ static zend_object *BreakIterator_clone_obj(zval *object TSRMLS_DC)
 		if (!new_biter) {
 			zend_string *err_msg;
 			intl_errors_set_code(BREAKITER_ERROR_P(bio_orig),
-				U_MEMORY_ALLOCATION_ERROR TSRMLS_CC);
+				U_MEMORY_ALLOCATION_ERROR);
 			intl_errors_set_custom_msg(BREAKITER_ERROR_P(bio_orig),
-				"Could not clone BreakIterator", 0 TSRMLS_CC);
-			err_msg = intl_error_get_message(BREAKITER_ERROR_P(bio_orig) TSRMLS_CC);
-			zend_throw_exception(NULL, err_msg->val, 0 TSRMLS_CC);
+				"Could not clone BreakIterator", 0);
+			err_msg = intl_error_get_message(BREAKITER_ERROR_P(bio_orig));
+			zend_throw_exception(NULL, err_msg->val, 0);
 			zend_string_free(err_msg);
 		} else {
 			bio_new->biter = new_biter;
 			ZVAL_COPY(&bio_new->text, &bio_orig->text);
 		}
 	} else {
-		zend_throw_exception(NULL, "Cannot clone unconstructed BreakIterator", 0 TSRMLS_CC);
+		zend_throw_exception(NULL, "Cannot clone unconstructed BreakIterator", 0);
 	}
 
 	return ret_val;
@@ -135,7 +135,7 @@ static zend_object *BreakIterator_clone_obj(zval *object TSRMLS_DC)
 /* }}} */
 
 /* {{{ get_debug_info handler for BreakIterator */
-static HashTable *BreakIterator_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
+static HashTable *BreakIterator_get_debug_info(zval *object, int *is_temp)
 {
 	zval val;
 	HashTable *debug_info;
@@ -176,23 +176,23 @@ static HashTable *BreakIterator_get_debug_info(zval *object, int *is_temp TSRMLS
 /* {{{ void breakiterator_object_init(BreakIterator_object* to)
  * Initialize internals of BreakIterator_object not specific to zend standard objects.
  */
-static void breakiterator_object_init(BreakIterator_object *bio TSRMLS_DC)
+static void breakiterator_object_init(BreakIterator_object *bio)
 {
-	intl_error_init(BREAKITER_ERROR_P(bio) TSRMLS_CC);
+	intl_error_init(BREAKITER_ERROR_P(bio));
 	bio->biter = NULL;
 	ZVAL_UNDEF(&bio->text);
 }
 /* }}} */
 
 /* {{{ BreakIterator_objects_dtor */
-static void BreakIterator_objects_dtor(zend_object *object TSRMLS_DC)
+static void BreakIterator_objects_dtor(zend_object *object)
 {
-	zend_objects_destroy_object(object TSRMLS_CC);
+	zend_objects_destroy_object(object);
 }
 /* }}} */
 
 /* {{{ BreakIterator_objects_free */
-static void BreakIterator_objects_free(zend_object *object TSRMLS_DC)
+static void BreakIterator_objects_free(zend_object *object)
 {
 	BreakIterator_object* bio = php_intl_breakiterator_fetch_object(object);
 
@@ -201,22 +201,22 @@ static void BreakIterator_objects_free(zend_object *object TSRMLS_DC)
 		delete bio->biter;
 		bio->biter = NULL;
 	}
-	intl_error_reset(BREAKITER_ERROR_P(bio) TSRMLS_CC);
+	intl_error_reset(BREAKITER_ERROR_P(bio));
 
-	zend_object_std_dtor(&bio->zo TSRMLS_CC);
+	zend_object_std_dtor(&bio->zo);
 }
 /* }}} */
 
 /* {{{ BreakIterator_object_create */
-static zend_object *BreakIterator_object_create(zend_class_entry *ce TSRMLS_DC)
+static zend_object *BreakIterator_object_create(zend_class_entry *ce)
 {
 	BreakIterator_object*	intern;
 
 	intern = (BreakIterator_object*)ecalloc(1, sizeof(BreakIterator_object) + sizeof(zval) * (ce->default_properties_count - 1));
 
-	zend_object_std_init(&intern->zo, ce TSRMLS_CC);
+	zend_object_std_init(&intern->zo, ce);
     object_properties_init((zend_object*) intern, ce);
-	breakiterator_object_init(intern TSRMLS_CC);
+	breakiterator_object_init(intern);
 
 	intern->zo.handlers = &BreakIterator_handlers;
 
@@ -316,7 +316,7 @@ static const zend_function_entry CodePointBreakIterator_class_functions[] = {
 /* {{{ breakiterator_register_BreakIterator_class
  * Initialize 'BreakIterator' class
  */
-U_CFUNC void breakiterator_register_BreakIterator_class(TSRMLS_D)
+U_CFUNC void breakiterator_register_BreakIterator_class(void)
 {
 	zend_class_entry ce;
 
@@ -324,7 +324,7 @@ U_CFUNC void breakiterator_register_BreakIterator_class(TSRMLS_D)
 	INIT_CLASS_ENTRY(ce, "IntlBreakIterator", BreakIterator_class_functions);
 	ce.create_object = BreakIterator_object_create;
 	ce.get_iterator = _breakiterator_get_iterator;
-	BreakIterator_ce_ptr = zend_register_internal_class(&ce TSRMLS_CC);
+	BreakIterator_ce_ptr = zend_register_internal_class(&ce);
 
 	memcpy(&BreakIterator_handlers, zend_get_std_object_handlers(),
 		sizeof BreakIterator_handlers);
@@ -335,16 +335,16 @@ U_CFUNC void breakiterator_register_BreakIterator_class(TSRMLS_D)
 	BreakIterator_handlers.dtor_obj = BreakIterator_objects_dtor;
 	BreakIterator_handlers.free_obj = BreakIterator_objects_free;
 
-	zend_class_implements(BreakIterator_ce_ptr TSRMLS_CC, 1,
+	zend_class_implements(BreakIterator_ce_ptr, 1,
 			zend_ce_traversable);
 
 	zend_declare_class_constant_long(BreakIterator_ce_ptr,
-		"DONE", sizeof("DONE") - 1, BreakIterator::DONE TSRMLS_CC );
+		"DONE", sizeof("DONE") - 1, BreakIterator::DONE );
 
 	/* Declare constants that are defined in the C header */
 #define BREAKITER_DECL_LONG_CONST(name) \
 	zend_declare_class_constant_long(BreakIterator_ce_ptr, #name, \
-		sizeof(#name) - 1, UBRK_ ## name TSRMLS_CC)
+		sizeof(#name) - 1, UBRK_ ## name)
 
 	BREAKITER_DECL_LONG_CONST(WORD_NONE);
 	BREAKITER_DECL_LONG_CONST(WORD_NONE_LIMIT);
@@ -374,12 +374,12 @@ U_CFUNC void breakiterator_register_BreakIterator_class(TSRMLS_D)
 	INIT_CLASS_ENTRY(ce, "IntlRuleBasedBreakIterator",
 			RuleBasedBreakIterator_class_functions);
 	RuleBasedBreakIterator_ce_ptr = zend_register_internal_class_ex(&ce,
-			BreakIterator_ce_ptr TSRMLS_CC);
+			BreakIterator_ce_ptr);
 
 	/* Create and register 'CodePointBreakIterator' class. */
 	INIT_CLASS_ENTRY(ce, "IntlCodePointBreakIterator",
 			CodePointBreakIterator_class_functions);
 	CodePointBreakIterator_ce_ptr = zend_register_internal_class_ex(&ce,
-			BreakIterator_ce_ptr TSRMLS_CC);
+			BreakIterator_ce_ptr);
 }
 /* }}} */
diff --git a/ext/intl/breakiterator/breakiterator_class.h b/ext/intl/breakiterator/breakiterator_class.h
index 6333003981..d1b5ebb2c8 100644
--- a/ext/intl/breakiterator/breakiterator_class.h
+++ b/ext/intl/breakiterator/breakiterator_class.h
@@ -58,15 +58,15 @@ static inline BreakIterator_object *php_intl_breakiterator_fetch_object(zend_obj
 	BREAKITER_METHOD_FETCH_OBJECT_NO_CHECK; \
 	if (bio->biter == NULL) \
 	{ \
-		intl_errors_set(&bio->err, U_ILLEGAL_ARGUMENT_ERROR, "Found unconstructed BreakIterator", 0 TSRMLS_CC); \
+		intl_errors_set(&bio->err, U_ILLEGAL_ARGUMENT_ERROR, "Found unconstructed BreakIterator", 0); \
 		RETURN_FALSE; \
 	}
 
-void breakiterator_object_create(zval *object, BreakIterator *break_iter, int brand_new TSRMLS_DC);
+void breakiterator_object_create(zval *object, BreakIterator *break_iter, int brand_new);
 
-void breakiterator_object_construct(zval *object, BreakIterator *break_iter TSRMLS_DC);
+void breakiterator_object_construct(zval *object, BreakIterator *break_iter);
 
-void breakiterator_register_BreakIterator_class(TSRMLS_D);
+void breakiterator_register_BreakIterator_class(void);
 
 extern zend_class_entry *BreakIterator_ce_ptr,
 						*RuleBasedBreakIterator_ce_ptr;
diff --git a/ext/intl/breakiterator/breakiterator_iterators.cpp b/ext/intl/breakiterator/breakiterator_iterators.cpp
index 19de7bce34..624a813e54 100644
--- a/ext/intl/breakiterator/breakiterator_iterators.cpp
+++ b/ext/intl/breakiterator/breakiterator_iterators.cpp
@@ -36,30 +36,30 @@ static zend_object_handlers IntlPartsIterator_handlers;
 
 /* BreakIterator's iterator */
 
-inline BreakIterator *_breakiter_prolog(zend_object_iterator *iter TSRMLS_DC)
+inline BreakIterator *_breakiter_prolog(zend_object_iterator *iter)
 {
 	BreakIterator_object *bio;
 	bio = Z_INTL_BREAKITERATOR_P(&iter->data);
-	intl_errors_reset(BREAKITER_ERROR_P(bio) TSRMLS_CC);
+	intl_errors_reset(BREAKITER_ERROR_P(bio));
 	if (bio->biter == NULL) {
 		intl_errors_set(BREAKITER_ERROR_P(bio), U_INVALID_STATE_ERROR,
 			"The BreakIterator object backing the PHP iterator is not "
-			"properly constructed", 0 TSRMLS_CC);
+			"properly constructed", 0);
 	}
 	return bio->biter;
 }
 
-static void _breakiterator_destroy_it(zend_object_iterator *iter TSRMLS_DC)
+static void _breakiterator_destroy_it(zend_object_iterator *iter)
 {
 	zval_ptr_dtor(&iter->data);
 }
 
-static void _breakiterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
+static void _breakiterator_move_forward(zend_object_iterator *iter)
 {
-	BreakIterator *biter = _breakiter_prolog(iter TSRMLS_CC);
+	BreakIterator *biter = _breakiter_prolog(iter);
 	zoi_with_current *zoi_iter = (zoi_with_current*)iter;
 
-	iter->funcs->invalidate_current(iter TSRMLS_CC);
+	iter->funcs->invalidate_current(iter);
 
 	if (biter == NULL) {
 		return;
@@ -71,9 +71,9 @@ static void _breakiterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
 	} //else we've reached the end of the enum, nothing more is required
 }
 
-static void _breakiterator_rewind(zend_object_iterator *iter TSRMLS_DC)
+static void _breakiterator_rewind(zend_object_iterator *iter)
 {
-	BreakIterator *biter = _breakiter_prolog(iter TSRMLS_CC);
+	BreakIterator *biter = _breakiter_prolog(iter);
 	zoi_with_current *zoi_iter = (zoi_with_current*)iter;
 
 	int32_t pos = biter->first();
@@ -91,12 +91,12 @@ static zend_object_iterator_funcs breakiterator_iterator_funcs = {
 };
 
 U_CFUNC zend_object_iterator *_breakiterator_get_iterator(
-	zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
+	zend_class_entry *ce, zval *object, int by_ref)
 {
 	BreakIterator_object *bio;
 	if (by_ref) {
 		zend_throw_exception(NULL,
-			"Iteration by reference is not supported", 0 TSRMLS_CC);
+			"Iteration by reference is not supported", 0);
 		return NULL;
 	}
 
@@ -105,12 +105,12 @@ U_CFUNC zend_object_iterator *_breakiterator_get_iterator(
 
 	if (biter == NULL) {
 		zend_throw_exception(NULL,
-			"The BreakIterator is not properly constructed", 0 TSRMLS_CC);
+			"The BreakIterator is not properly constructed", 0);
 		return NULL;
 	}
 
 	zoi_with_current *zoi_iter = static_cast<zoi_with_current*>(emalloc(sizeof *zoi_iter));
-	zend_iterator_init(&zoi_iter->zoi TSRMLS_CC);
+	zend_iterator_init(&zoi_iter->zoi);
 	ZVAL_COPY(&zoi_iter->zoi.data, object);
 	zoi_iter->zoi.funcs = &breakiterator_iterator_funcs;
 	zoi_iter->zoi.index = 0;
@@ -129,23 +129,23 @@ typedef struct zoi_break_iter_parts {
 	BreakIterator_object *bio; /* so we don't have to fetch it all the time */
 } zoi_break_iter_parts;
 
-static void _breakiterator_parts_destroy_it(zend_object_iterator *iter TSRMLS_DC)
+static void _breakiterator_parts_destroy_it(zend_object_iterator *iter)
 {
 	zval_ptr_dtor(&iter->data);
 }
 
-static void _breakiterator_parts_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
+static void _breakiterator_parts_get_current_key(zend_object_iterator *iter, zval *key)
 {
 	/* the actual work is done in move_forward and rewind */
 	ZVAL_LONG(key, iter->index);
 }
 
-static void _breakiterator_parts_move_forward(zend_object_iterator *iter TSRMLS_DC)
+static void _breakiterator_parts_move_forward(zend_object_iterator *iter)
 {
 	zoi_break_iter_parts *zoi_bit = (zoi_break_iter_parts*)iter;
 	BreakIterator_object *bio = zoi_bit->bio;
 
-	iter->funcs->invalidate_current(iter TSRMLS_CC);
+	iter->funcs->invalidate_current(iter);
 
 	int32_t cur,
 			next;
@@ -183,18 +183,18 @@ static void _breakiterator_parts_move_forward(zend_object_iterator *iter TSRMLS_
 	ZVAL_STR(&zoi_bit->zoi_cur.current, res);
 }
 
-static void _breakiterator_parts_rewind(zend_object_iterator *iter TSRMLS_DC)
+static void _breakiterator_parts_rewind(zend_object_iterator *iter)
 {
 	zoi_break_iter_parts *zoi_bit = (zoi_break_iter_parts*)iter;
 	BreakIterator_object *bio = zoi_bit->bio;
 
 	if (!Z_ISUNDEF(zoi_bit->zoi_cur.current)) {
-		iter->funcs->invalidate_current(iter TSRMLS_CC);
+		iter->funcs->invalidate_current(iter);
 	}
 
 	bio->biter->first();
 
-	iter->funcs->move_forward(iter TSRMLS_CC);
+	iter->funcs->move_forward(iter);
 }
 
 static zend_object_iterator_funcs breakiterator_parts_it_funcs = {
@@ -209,7 +209,7 @@ static zend_object_iterator_funcs breakiterator_parts_it_funcs = {
 
 void IntlIterator_from_BreakIterator_parts(zval *break_iter_zv,
 										   zval *object,
-										   parts_iter_key_type key_type TSRMLS_DC)
+										   parts_iter_key_type key_type)
 {
 	IntlIterator_object *ii;
 
@@ -217,7 +217,7 @@ void IntlIterator_from_BreakIterator_parts(zval *break_iter_zv,
 	ii = Z_INTL_ITERATOR_P(object);
 
 	ii->iterator = (zend_object_iterator*)emalloc(sizeof(zoi_break_iter_parts));
-	zend_iterator_init(ii->iterator TSRMLS_CC);
+	zend_iterator_init(ii->iterator);
 
 	ZVAL_COPY(&ii->iterator->data, break_iter_zv);
 	ii->iterator->funcs = &breakiterator_parts_it_funcs;
@@ -234,15 +234,15 @@ void IntlIterator_from_BreakIterator_parts(zval *break_iter_zv,
 	((zoi_break_iter_parts*)ii->iterator)->key_type = key_type;
 }
 
-U_CFUNC zend_object *IntlPartsIterator_object_create(zend_class_entry *ce TSRMLS_DC)
+U_CFUNC zend_object *IntlPartsIterator_object_create(zend_class_entry *ce)
 {
-	zend_object *retval = IntlIterator_ce_ptr->create_object(ce TSRMLS_CC);
+	zend_object *retval = IntlIterator_ce_ptr->create_object(ce);
 	retval->handlers = &IntlPartsIterator_handlers;
 
 	return retval;
 }
 
-U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, zend_string *method, const zval *key TSRMLS_DC)
+U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, zend_string *method, const zval *key)
 {
 	zend_function *ret;
 	zend_string *lc_method_name;
@@ -261,12 +261,12 @@ U_CFUNC zend_function *IntlPartsIterator_get_method(zend_object **object_ptr, ze
 		if (obj->iterator && !Z_ISUNDEF(obj->iterator->data)) {
 			zval *break_iter_zv = &obj->iterator->data;
 			*object_ptr = Z_OBJ_P(break_iter_zv);
-			ret = Z_OBJ_HANDLER_P(break_iter_zv, get_method)(object_ptr, method, key TSRMLS_CC);
+			ret = Z_OBJ_HANDLER_P(break_iter_zv, get_method)(object_ptr, method, key);
 			goto end;
 		}
 	}
 
-	ret = std_object_handlers.get_method(object_ptr, method, key TSRMLS_CC);
+	ret = std_object_handlers.get_method(object_ptr, method, key);
 
 end:
 	if (key == NULL) {
@@ -282,7 +282,7 @@ U_CFUNC PHP_METHOD(IntlPartsIterator, getBreakIterator)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"IntlPartsIterator::getBreakIterator: bad arguments", 0 TSRMLS_CC);
+			"IntlPartsIterator::getBreakIterator: bad arguments", 0);
 		return;
 	}
 
@@ -300,14 +300,14 @@ static const zend_function_entry IntlPartsIterator_class_functions[] = {
 	PHP_FE_END
 };
 
-U_CFUNC void breakiterator_register_IntlPartsIterator_class(TSRMLS_D)
+U_CFUNC void breakiterator_register_IntlPartsIterator_class(void)
 {
 	zend_class_entry ce;
 
 	/* Create and register 'BreakIterator' class. */
 	INIT_CLASS_ENTRY(ce, "IntlPartsIterator", IntlPartsIterator_class_functions);
 	IntlPartsIterator_ce_ptr = zend_register_internal_class_ex(&ce,
-			IntlIterator_ce_ptr TSRMLS_CC);
+			IntlIterator_ce_ptr);
 	IntlPartsIterator_ce_ptr->create_object = IntlPartsIterator_object_create;
 
 	memcpy(&IntlPartsIterator_handlers, &IntlIterator_handlers,
@@ -316,7 +316,7 @@ U_CFUNC void breakiterator_register_IntlPartsIterator_class(TSRMLS_D)
 
 #define PARTSITER_DECL_LONG_CONST(name) \
 	zend_declare_class_constant_long(IntlPartsIterator_ce_ptr, #name, \
-		sizeof(#name) - 1, PARTS_ITERATOR_ ## name TSRMLS_CC)
+		sizeof(#name) - 1, PARTS_ITERATOR_ ## name)
 
 	PARTSITER_DECL_LONG_CONST(KEY_SEQUENTIAL);
 	PARTSITER_DECL_LONG_CONST(KEY_LEFT);
diff --git a/ext/intl/breakiterator/breakiterator_iterators.h b/ext/intl/breakiterator/breakiterator_iterators.h
index 764f4f4426..71a1e35025 100644
--- a/ext/intl/breakiterator/breakiterator_iterators.h
+++ b/ext/intl/breakiterator/breakiterator_iterators.h
@@ -32,11 +32,11 @@ typedef enum {
 #ifdef __cplusplus
 void IntlIterator_from_BreakIterator_parts(zval *break_iter_zv,
 										   zval *object,
-										   parts_iter_key_type key_type TSRMLS_DC);
+										   parts_iter_key_type key_type);
 #endif
 
 U_CFUNC zend_object_iterator *_breakiterator_get_iterator(
-		zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
-U_CFUNC void breakiterator_register_IntlPartsIterator_class(TSRMLS_D);
+		zend_class_entry *ce, zval *object, int by_ref);
+U_CFUNC void breakiterator_register_IntlPartsIterator_class(void);
 
 #endif
diff --git a/ext/intl/breakiterator/breakiterator_methods.cpp b/ext/intl/breakiterator/breakiterator_methods.cpp
index 1153340e14..64c85bad73 100644
--- a/ext/intl/breakiterator/breakiterator_methods.cpp
+++ b/ext/intl/breakiterator/breakiterator_methods.cpp
@@ -37,7 +37,7 @@ U_CFUNC PHP_METHOD(BreakIterator, __construct)
 {
 	zend_throw_exception( NULL,
 		"An object of this type cannot be created with the new operator",
-		0 TSRMLS_CC );
+		0 );
 }
 
 static void _breakiter_factory(const char *func_name,
@@ -49,31 +49,31 @@ static void _breakiter_factory(const char *func_name,
 	size_t				dummy;
 	char			*msg;
 	UErrorCode		status = UErrorCode();
-	intl_error_reset(NULL TSRMLS_CC);
+	intl_error_reset(NULL);
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!",
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s!",
 			&locale_str, &dummy) == FAILURE) {
 		spprintf(&msg, 0, "%s: bad arguments", func_name);
-		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
+		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1);
 		efree(msg);
 		RETURN_NULL();
 	}
 
 	if (locale_str == NULL) {
-		locale_str = intl_locale_get_default(TSRMLS_C);
+		locale_str = intl_locale_get_default();
 	}
 
 	biter = func(Locale::createFromName(locale_str), status);
-	intl_error_set_code(NULL, status TSRMLS_CC);
+	intl_error_set_code(NULL, status);
 	if (U_FAILURE(status)) {
 		spprintf(&msg, 0, "%s: error creating BreakIterator",
 				func_name);
-		intl_error_set_custom_msg(NULL, msg, 1 TSRMLS_CC);
+		intl_error_set_custom_msg(NULL, msg, 1);
 		efree(msg);
 		RETURN_NULL();
 	}
 
-	breakiterator_object_create(return_value, biter, 1 TSRMLS_CC);
+	breakiterator_object_create(return_value, biter, 1);
 }
 
 U_CFUNC PHP_FUNCTION(breakiter_create_word_instance)
@@ -114,16 +114,16 @@ U_CFUNC PHP_FUNCTION(breakiter_create_title_instance)
 U_CFUNC PHP_FUNCTION(breakiter_create_code_point_instance)
 {
 	UErrorCode status = UErrorCode();
-	intl_error_reset(NULL TSRMLS_CC);
+	intl_error_reset(NULL);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_create_code_point_instance: bad arguments", 0 TSRMLS_CC);
+			"breakiter_create_code_point_instance: bad arguments", 0);
 		RETURN_NULL();
 	}
 
 	CodePointBreakIterator *cpbi = new CodePointBreakIterator();
-	breakiterator_object_create(return_value, cpbi, 1 TSRMLS_CC);
+	breakiterator_object_create(return_value, cpbi, 1);
 }
 
 U_CFUNC PHP_FUNCTION(breakiter_get_text)
@@ -133,7 +133,7 @@ U_CFUNC PHP_FUNCTION(breakiter_get_text)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_get_text: bad arguments", 0 TSRMLS_CC);
+			"breakiter_get_text: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -155,10 +155,10 @@ U_CFUNC PHP_FUNCTION(breakiter_set_text)
 	BREAKITER_METHOD_INIT_VARS;
 	object = getThis();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
 			&text, &text_len) == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_set_text: bad arguments", 0 TSRMLS_CC);
+			"breakiter_set_text: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -199,7 +199,7 @@ static void _breakiter_no_args_ret_int32(
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		spprintf(&msg, 0, "%s: bad arguments", func_name);
-		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
+		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1);
 		efree(msg);
 		RETURN_FALSE;
 	}
@@ -221,9 +221,9 @@ static void _breakiter_int32_ret_int32(
 	BREAKITER_METHOD_INIT_VARS;
 	object = getThis();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &arg) == FAILURE) {
 		spprintf(&msg, 0, "%s: bad arguments", func_name);
-		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
+		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1);
 		efree(msg);
 		RETURN_FALSE;
 	}
@@ -233,7 +233,7 @@ static void _breakiter_int32_ret_int32(
 	if (arg < INT32_MIN || arg > INT32_MAX) {
 		spprintf(&msg, 0, "%s: offset argument is outside bounds of "
 				"a 32-bit wide integer", func_name);
-		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1 TSRMLS_CC);
+		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, msg, 1);
 		efree(msg);
 		RETURN_FALSE;
 	}
@@ -300,7 +300,7 @@ U_CFUNC PHP_FUNCTION(breakiter_current)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-				"breakiter_current: bad arguments", 0 TSRMLS_CC);
+				"breakiter_current: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -331,17 +331,17 @@ U_CFUNC PHP_FUNCTION(breakiter_is_boundary)
 	BREAKITER_METHOD_INIT_VARS;
 	object = getThis();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l",
 			&offset) == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-				"breakiter_is_boundary: bad arguments", 0 TSRMLS_CC);
+				"breakiter_is_boundary: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
 	if (offset < INT32_MIN || offset > INT32_MAX) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
 				"breakiter_is_boundary: offset argument is outside bounds of "
-				"a 32-bit wide integer", 0 TSRMLS_CC);
+				"a 32-bit wide integer", 0);
 		RETURN_FALSE;
 	}
 
@@ -358,15 +358,15 @@ U_CFUNC PHP_FUNCTION(breakiter_get_locale)
 	BREAKITER_METHOD_INIT_VARS;
 	object = getThis();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &locale_type) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &locale_type) == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_get_locale: bad arguments", 0 TSRMLS_CC);
+			"breakiter_get_locale: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
 	if (locale_type != ULOC_ACTUAL_LOCALE && locale_type != ULOC_VALID_LOCALE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_get_locale: invalid locale type", 0 TSRMLS_CC);
+			"breakiter_get_locale: invalid locale type", 0);
 		RETURN_FALSE;
 	}
 
@@ -386,9 +386,9 @@ U_CFUNC PHP_FUNCTION(breakiter_get_parts_iterator)
 	BREAKITER_METHOD_INIT_VARS;
 	object = getThis();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &key_type) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &key_type) == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_get_parts_iterator: bad arguments", 0 TSRMLS_CC);
+			"breakiter_get_parts_iterator: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -396,14 +396,14 @@ U_CFUNC PHP_FUNCTION(breakiter_get_parts_iterator)
 			&& key_type != PARTS_ITERATOR_KEY_LEFT
 			&& key_type != PARTS_ITERATOR_KEY_RIGHT) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_get_parts_iterator: bad key type", 0 TSRMLS_CC);
+			"breakiter_get_parts_iterator: bad key type", 0);
 		RETURN_FALSE;
 	}
 
 	BREAKITER_METHOD_FETCH_OBJECT;
 
 	IntlIterator_from_BreakIterator_parts(
-		object, return_value, (parts_iter_key_type)key_type TSRMLS_CC);
+		object, return_value, (parts_iter_key_type)key_type);
 }
 
 U_CFUNC PHP_FUNCTION(breakiter_get_error_code)
@@ -413,7 +413,7 @@ U_CFUNC PHP_FUNCTION(breakiter_get_error_code)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_get_error_code: bad arguments", 0 TSRMLS_CC);
+			"breakiter_get_error_code: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -433,7 +433,7 @@ U_CFUNC PHP_FUNCTION(breakiter_get_error_message)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"breakiter_get_error_message: bad arguments", 0 TSRMLS_CC );
+			"breakiter_get_error_message: bad arguments", 0 );
 		RETURN_FALSE;
 	}
 
@@ -444,6 +444,6 @@ U_CFUNC PHP_FUNCTION(breakiter_get_error_message)
 		RETURN_FALSE;
 
 	/* Return last error message. */
-	message = intl_error_get_message(BREAKITER_ERROR_P(bio) TSRMLS_CC);
+	message = intl_error_get_message(BREAKITER_ERROR_P(bio));
 	RETURN_STR(message);
 }
diff --git a/ext/intl/breakiterator/codepointiterator_methods.cpp b/ext/intl/breakiterator/codepointiterator_methods.cpp
index d7fe359712..f916915ae2 100644
--- a/ext/intl/breakiterator/codepointiterator_methods.cpp
+++ b/ext/intl/breakiterator/codepointiterator_methods.cpp
@@ -34,7 +34,7 @@ U_CFUNC PHP_FUNCTION(cpbi_get_last_code_point)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"cpbi_get_last_code_point: bad arguments", 0 TSRMLS_CC);
+			"cpbi_get_last_code_point: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
diff --git a/ext/intl/breakiterator/rulebasedbreakiterator_methods.cpp b/ext/intl/breakiterator/rulebasedbreakiterator_methods.cpp
index d3b36291b2..be38396466 100644
--- a/ext/intl/breakiterator/rulebasedbreakiterator_methods.cpp
+++ b/ext/intl/breakiterator/rulebasedbreakiterator_methods.cpp
@@ -36,12 +36,12 @@ static void _php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAMETERS)
 	size_t			rules_len;
 	zend_bool	compiled	= 0;
 	UErrorCode	status		= U_ZERO_ERROR;
-	intl_error_reset(NULL TSRMLS_CC);
+	intl_error_reset(NULL);
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b",
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b",
 			&rules, &rules_len, &compiled) == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"rbbi_create_instance: bad arguments", 0 TSRMLS_CC);
+			"rbbi_create_instance: bad arguments", 0);
 		Z_OBJ_P(return_value) = NULL;
 		return;
 	}
@@ -56,12 +56,12 @@ static void _php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAMETERS)
 				== FAILURE) {
 			intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
 				"rbbi_create_instance: rules were not a valid UTF-8 string",
-				0 TSRMLS_CC);
+				0);
 			RETURN_NULL();
 		}
 
 		rbbi = new RuleBasedBreakIterator(rulesStr, parseError, status);
-		intl_error_set_code(NULL, status TSRMLS_CC);
+		intl_error_set_code(NULL, status);
 		if (U_FAILURE(status)) {
 			char *msg;
 			smart_str parse_error_str;
@@ -69,7 +69,7 @@ static void _php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAMETERS)
 			spprintf(&msg, 0, "rbbi_create_instance: unable to create "
 				"RuleBasedBreakIterator from rules (%s)", parse_error_str.s? parse_error_str.s->val : "");
 			smart_str_free(&parse_error_str);
-			intl_error_set_custom_msg(NULL, msg, 1 TSRMLS_CC);
+			intl_error_set_custom_msg(NULL, msg, 1);
 			efree(msg);
 			delete rbbi;
 			Z_OBJ_P(return_value) = NULL;
@@ -80,19 +80,19 @@ static void _php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAMETERS)
 		rbbi = new RuleBasedBreakIterator((uint8_t*)rules, rules_len, status);
 		if (U_FAILURE(status)) {
 			intl_error_set(NULL, status, "rbbi_create_instance: unable to "
-				"create instance from compiled rules", 0 TSRMLS_CC);
+				"create instance from compiled rules", 0);
 			Z_OBJ_P(return_value) = NULL;
 			return;
 		}
 #else
 		intl_error_set(NULL, U_UNSUPPORTED_ERROR, "rbbi_create_instance: "
-			"compiled rules require ICU >= 4.8", 0 TSRMLS_CC);
+			"compiled rules require ICU >= 4.8", 0);
 		Z_OBJ_P(return_value) = NULL;
 		return;
 #endif
 	}
 
-	breakiterator_object_create(return_value, rbbi, 0 TSRMLS_CC);
+	breakiterator_object_create(return_value, rbbi, 0);
 }
 
 U_CFUNC PHP_METHOD(IntlRuleBasedBreakIterator, __construct)
@@ -103,7 +103,7 @@ U_CFUNC PHP_METHOD(IntlRuleBasedBreakIterator, __construct)
 	_php_intlrbbi_constructor_body(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 
 	if (Z_TYPE_P(return_value) == IS_OBJECT && Z_OBJ_P(return_value) == NULL) {
-		zend_object_store_ctor_failed(Z_OBJ(orig_this) TSRMLS_CC);
+		zend_object_store_ctor_failed(Z_OBJ(orig_this));
 		zval_dtor(&orig_this);
 		ZEND_CTOR_MAKE_NULL();
 	}
@@ -116,7 +116,7 @@ U_CFUNC PHP_FUNCTION(rbbi_get_rules)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"rbbi_get_rules: bad arguments", 0 TSRMLS_CC);
+			"rbbi_get_rules: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -130,7 +130,7 @@ U_CFUNC PHP_FUNCTION(rbbi_get_rules)
 	{
 		intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
 				"rbbi_hash_code: Error converting result to UTF-8 string",
-				0 TSRMLS_CC);
+				0);
 		RETURN_FALSE;
 	}
 	RETVAL_STRINGL(str, str_len);
@@ -145,7 +145,7 @@ U_CFUNC PHP_FUNCTION(rbbi_get_rule_status)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"rbbi_get_rule_status: bad arguments", 0 TSRMLS_CC);
+			"rbbi_get_rule_status: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -161,7 +161,7 @@ U_CFUNC PHP_FUNCTION(rbbi_get_rule_status_vec)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"rbbi_get_rule_status_vec: bad arguments", 0 TSRMLS_CC);
+			"rbbi_get_rule_status_vec: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -183,7 +183,7 @@ U_CFUNC PHP_FUNCTION(rbbi_get_rule_status_vec)
 		delete[] rules;
 		intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
 				"rbbi_get_rule_status_vec: failed obtaining the status values",
-				0 TSRMLS_CC);
+				0);
 		RETURN_FALSE;
 	}
 
@@ -202,7 +202,7 @@ U_CFUNC PHP_FUNCTION(rbbi_get_binary_rules)
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
-			"rbbi_get_binary_rules: bad arguments", 0 TSRMLS_CC);
+			"rbbi_get_binary_rules: bad arguments", 0);
 		RETURN_FALSE;
 	}
 
@@ -214,7 +214,7 @@ U_CFUNC PHP_FUNCTION(rbbi_get_binary_rules)
 	if (rules_len > INT_MAX - 1) {
 		intl_errors_set(BREAKITER_ERROR_P(bio), BREAKITER_ERROR_CODE(bio),
 				"rbbi_get_binary_rules: the rules are too large",
-				0 TSRMLS_CC);
+				0);
 		RETURN_FALSE;
 	}