first shot remove TSRMLS_* things

13 files changed, 407 insertions, 407 deletions

diff --git a/ext/com_dotnet/com_com.c b/ext/com_dotnet/com_com.c
index 7de6d949bb..9dc6f23801 100644
--- a/ext/com_dotnet/com_com.c
+++ b/ext/com_dotnet/com_com.c
@@ -53,19 +53,19 @@ PHP_FUNCTION(com_create_instance)
 		&authid, EOAC_NONE
 	};
 
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	obj = CDNO_FETCH(object);
 
 	if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "s|s!ls",
+			ZEND_NUM_ARGS(), "s|s!ls",
 			&module_name, &module_name_len, &server_name, &server_name_len,
 			&obj->code_page, &typelib_name, &typelib_name_len) &&
 		FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "sa|ls",
+			ZEND_NUM_ARGS(), "sa|ls",
 			&module_name, &module_name_len, &server_params, &obj->code_page,
 			&typelib_name, &typelib_name_len)) {
 
-		php_com_throw_exception(E_INVALIDARG, "Could not create COM object - invalid arguments!" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "Could not create COM object - invalid arguments!");
 		ZEND_CTOR_MAKE_NULL();
 		return;
 	}
@@ -114,21 +114,21 @@ PHP_FUNCTION(com_create_instance)
 	}
 
 	if (server_name && !COMG(allow_dcom)) {
-		php_com_throw_exception(E_ERROR, "DCOM has been disabled by your administrator [com.allow_dcom=0]" TSRMLS_CC);
+		php_com_throw_exception(E_ERROR, "DCOM has been disabled by your administrator [com.allow_dcom=0]");
 		return;
 	}
 
-	moniker = php_com_string_to_olestring(module_name, module_name_len, obj->code_page TSRMLS_CC);
+	moniker = php_com_string_to_olestring(module_name, module_name_len, obj->code_page);
 
 	/* if instantiating a remote object, either directly, or via
 	 * a moniker, fill in the relevant info */
 	if (server_name) {
 		info.dwReserved1 = 0;
 		info.dwReserved2 = 0;
-		info.pwszName = php_com_string_to_olestring(server_name, server_name_len, obj->code_page TSRMLS_CC);
+		info.pwszName = php_com_string_to_olestring(server_name, server_name_len, obj->code_page);
 
 		if (user_name) {
-			authid.User = php_com_string_to_olestring(user_name, -1, obj->code_page TSRMLS_CC);
+			authid.User = php_com_string_to_olestring(user_name, -1, obj->code_page);
 			authid.UserLength = (ULONG)user_name_len;
 
 			if (password) {
@@ -228,7 +228,7 @@ PHP_FUNCTION(com_create_instance)
 		spprintf(&msg, 0, "Failed to create COM object `%s': %s", module_name, werr);
 		LocalFree(werr);
 
-		php_com_throw_exception(res, msg TSRMLS_CC);
+		php_com_throw_exception(res, msg);
 		efree(msg);
 		ZEND_CTOR_MAKE_NULL();
 		return;
@@ -241,11 +241,11 @@ PHP_FUNCTION(com_create_instance)
 		/* load up the library from the named file */
 		int cached;
 
-		TL = php_com_load_typelib_via_cache(typelib_name, obj->code_page, &cached TSRMLS_CC);
+		TL = php_com_load_typelib_via_cache(typelib_name, obj->code_page, &cached);
 
 		if (TL) {
 			if (COMG(autoreg_on) && !cached) {
-				php_com_import_typelib(TL, mode, obj->code_page TSRMLS_CC);
+				php_com_import_typelib(TL, mode, obj->code_page);
 			}
 
 			/* cross your fingers... there is no guarantee that this ITypeInfo
@@ -261,10 +261,10 @@ PHP_FUNCTION(com_create_instance)
 			BSTR name;
 
 			if (SUCCEEDED(ITypeLib_GetDocumentation(TL, -1, &name, NULL, NULL, NULL))) {
-				typelib_name = php_com_olestring_to_string(name, &typelib_name_len, obj->code_page TSRMLS_CC);
+				typelib_name = php_com_olestring_to_string(name, &typelib_name_len, obj->code_page);
 
 				if (NULL != zend_ts_hash_str_add_ptr(&php_com_typelibraries, typelib_name, typelib_name_len, TL)) {
-					php_com_import_typelib(TL, mode, obj->code_page TSRMLS_CC);
+					php_com_import_typelib(TL, mode, obj->code_page);
 
 					/* add a reference for the hash */
 					ITypeLib_AddRef(TL);
@@ -272,7 +272,7 @@ PHP_FUNCTION(com_create_instance)
 
 			} else {
 				/* try it anyway */
-				php_com_import_typelib(TL, mode, obj->code_page TSRMLS_CC);
+				php_com_import_typelib(TL, mode, obj->code_page);
 			}
 
 			ITypeLib_Release(TL);
@@ -295,32 +295,32 @@ PHP_FUNCTION(com_get_active_object)
 	HRESULT res;
 	OLECHAR *module = NULL;
 
-	php_com_initialize(TSRMLS_C);
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l",
+	php_com_initialize();
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "s|l",
 				&module_name, &module_name_len, &code_page)) {
-		php_com_throw_exception(E_INVALIDARG, "Invalid arguments!" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "Invalid arguments!");
 		return;
 	}
 
-	module = php_com_string_to_olestring(module_name, module_name_len, (int)code_page TSRMLS_CC);
+	module = php_com_string_to_olestring(module_name, module_name_len, (int)code_page);
 
 	res = CLSIDFromString(module, &clsid);
 
 	if (FAILED(res)) {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 	} else {
 		res = GetActiveObject(&clsid, NULL, &unk);
 
 		if (FAILED(res)) {
-			php_com_throw_exception(res, NULL TSRMLS_CC);
+			php_com_throw_exception(res, NULL);
 		} else {
 			res = IUnknown_QueryInterface(unk, &IID_IDispatch, &obj);
 
 			if (FAILED(res)) {
-				php_com_throw_exception(res, NULL TSRMLS_CC);
+				php_com_throw_exception(res, NULL);
 			} else if (obj) {
 				/* we got our dispatchable object */
-				php_com_wrap_dispatch(return_value, obj, (int)code_page TSRMLS_CC);
+				php_com_wrap_dispatch(return_value, obj, (int)code_page);
 			}
 		}
 	}
@@ -338,7 +338,7 @@ PHP_FUNCTION(com_get_active_object)
 /* Performs an Invoke on the given com object.
  * returns a failure code and creates an exception if there was an error */
 HRESULT php_com_invoke_helper(php_com_dotnet_object *obj, DISPID id_member,
-		WORD flags, DISPPARAMS *disp_params, VARIANT *v, int silent, int allow_noarg TSRMLS_DC)
+		WORD flags, DISPPARAMS *disp_params, VARIANT *v, int silent, int allow_noarg)
 {
 	HRESULT hr;
 	unsigned int arg_err;
@@ -354,11 +354,11 @@ HRESULT php_com_invoke_helper(php_com_dotnet_object *obj, DISPID id_member,
 		switch (hr) {
 			case DISP_E_EXCEPTION:
 				if (e.bstrSource) {
-					source = php_com_olestring_to_string(e.bstrSource, &source_len, obj->code_page TSRMLS_CC);
+					source = php_com_olestring_to_string(e.bstrSource, &source_len, obj->code_page);
 					SysFreeString(e.bstrSource);
 				}
 				if (e.bstrDescription) {
-					desc = php_com_olestring_to_string(e.bstrDescription, &desc_len, obj->code_page TSRMLS_CC);
+					desc = php_com_olestring_to_string(e.bstrDescription, &desc_len, obj->code_page);
 					SysFreeString(e.bstrDescription);
 				}
 				if (PG(html_errors)) {
@@ -406,7 +406,7 @@ HRESULT php_com_invoke_helper(php_com_dotnet_object *obj, DISPID id_member,
 		}
 
 		if (msg) {
-			php_com_throw_exception(hr, msg TSRMLS_CC);
+			php_com_throw_exception(hr, msg);
 			efree(msg);
 		}
 	}
@@ -416,7 +416,7 @@ HRESULT php_com_invoke_helper(php_com_dotnet_object *obj, DISPID id_member,
 
 /* map an ID to a name */
 HRESULT php_com_get_id_of_name(php_com_dotnet_object *obj, char *name,
-		size_t namelen, DISPID *dispid TSRMLS_DC)
+		size_t namelen, DISPID *dispid)
 {
 	OLECHAR *olename;
 	HRESULT hr;
@@ -431,7 +431,7 @@ HRESULT php_com_get_id_of_name(php_com_dotnet_object *obj, char *name,
 		return S_OK;
 	}
 	
-	olename = php_com_string_to_olestring(name, namelen, obj->code_page TSRMLS_CC);
+	olename = php_com_string_to_olestring(name, namelen, obj->code_page);
 
 	if (obj->typeinfo) {
 		hr = ITypeInfo_GetIDsOfNames(obj->typeinfo, &olename, 1, dispid);
@@ -465,7 +465,7 @@ HRESULT php_com_get_id_of_name(php_com_dotnet_object *obj, char *name,
 
 /* the core of COM */
 int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *f,
-		WORD flags,	VARIANT *v, int nargs, zval *args TSRMLS_DC)
+		WORD flags,	VARIANT *v, int nargs, zval *args)
 {
 	DISPID dispid, altdispid;
 	DISPPARAMS disp_params;
@@ -478,7 +478,7 @@ int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *
 		return FAILURE;
 	}
 	
-	hr = php_com_get_id_of_name(obj, f->function_name->val, f->function_name->len, &dispid TSRMLS_CC);
+	hr = php_com_get_id_of_name(obj, f->function_name->val, f->function_name->len, &dispid);
 
 	if (FAILED(hr)) {
 		char *winerr = NULL;
@@ -486,7 +486,7 @@ int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *
 		winerr = php_win32_error_to_msg(hr);
 		spprintf(&msg, 0, "Unable to lookup `%s': %s", f->function_name->val, winerr);
 		LocalFree(winerr);
-		php_com_throw_exception(hr, msg TSRMLS_CC);
+		php_com_throw_exception(hr, msg);
 		efree(msg);
 		return FAILURE;
 	}
@@ -509,7 +509,7 @@ int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *
 		for (j = 0, i = 0; i < nargs; i++) {
 			if (f->arg_info[nargs - i - 1].pass_by_reference) {
 				/* put the value into byref_vals instead */
-				php_com_variant_from_zval(&byref_vals[j], &args[nargs - i - 1], obj->code_page TSRMLS_CC);
+				php_com_variant_from_zval(&byref_vals[j], &args[nargs - i - 1], obj->code_page);
 
 				/* if it is already byref, "move" it into the vargs array, otherwise
 				 * make vargs a reference to this value */
@@ -524,14 +524,14 @@ int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *
 				}
 				j++;
 			} else {
-				php_com_variant_from_zval(&vargs[i], &args[nargs - i - 1], obj->code_page TSRMLS_CC);
+				php_com_variant_from_zval(&vargs[i], &args[nargs - i - 1], obj->code_page);
 			}
 		}
 		
 	} else {
 		/* Invoke'd args are in reverse order */
 		for (i = 0; i < nargs; i++) {
-			php_com_variant_from_zval(&vargs[i], &args[nargs - i - 1], obj->code_page TSRMLS_CC);
+			php_com_variant_from_zval(&vargs[i], &args[nargs - i - 1], obj->code_page);
 		}
 	}
 
@@ -547,7 +547,7 @@ int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *
 	}
 
 	/* this will create an exception if needed */
-	hr = php_com_invoke_helper(obj, dispid, flags, &disp_params, v, 0, 0 TSRMLS_CC);	
+	hr = php_com_invoke_helper(obj, dispid, flags, &disp_params, v, 0, 0);	
 
 	/* release variants */
 	if (vargs) {
@@ -564,13 +564,13 @@ int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *
 						if (vargs[i].byref == &V_UINT(&byref_vals[j])) {
 							/* copy that value */
 							php_com_zval_from_variant(&args[nargs - i - 1], &byref_vals[j],
-								obj->code_page TSRMLS_CC);
+								obj->code_page);
 						}
 					} else {
 						/* not sure if this can ever happen; the variant we marked as BYREF
 						 * is no longer BYREF - copy its value */
 						php_com_zval_from_variant(&args[nargs - i - 1], &vargs[i],
-							obj->code_page TSRMLS_CC);
+							obj->code_page);
 					}
 					VariantClear(&byref_vals[j]);
 					j++;
@@ -591,7 +591,7 @@ int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *
 
 
 int php_com_do_invoke_by_id(php_com_dotnet_object *obj, DISPID dispid,
-		WORD flags,	VARIANT *v, int nargs, zval *args, int silent, int allow_noarg TSRMLS_DC)
+		WORD flags,	VARIANT *v, int nargs, zval *args, int silent, int allow_noarg)
 {
 	DISPID altdispid;
 	DISPPARAMS disp_params;
@@ -605,7 +605,7 @@ int php_com_do_invoke_by_id(php_com_dotnet_object *obj, DISPID dispid,
 
 	/* Invoke'd args are in reverse order */
 	for (i = 0; i < nargs; i++) {
-		php_com_variant_from_zval(&vargs[i], &args[nargs - i - 1], obj->code_page TSRMLS_CC);
+		php_com_variant_from_zval(&vargs[i], &args[nargs - i - 1], obj->code_page);
 	}
 
 	disp_params.cArgs = nargs;
@@ -620,7 +620,7 @@ int php_com_do_invoke_by_id(php_com_dotnet_object *obj, DISPID dispid,
 	}
 
 	/* this will create an exception if needed */
-	hr = php_com_invoke_helper(obj, dispid, flags, &disp_params, v, silent, allow_noarg TSRMLS_CC);	
+	hr = php_com_invoke_helper(obj, dispid, flags, &disp_params, v, silent, allow_noarg);	
 
 	/* release variants */
 	if (vargs) {
@@ -638,25 +638,25 @@ int php_com_do_invoke_by_id(php_com_dotnet_object *obj, DISPID dispid,
 }
 
 int php_com_do_invoke(php_com_dotnet_object *obj, char *name, size_t namelen,
-		WORD flags,	VARIANT *v, int nargs, zval *args, int allow_noarg TSRMLS_DC)
+		WORD flags,	VARIANT *v, int nargs, zval *args, int allow_noarg)
 {
 	DISPID dispid;
 	HRESULT hr;
 	char *winerr = NULL;
 	char *msg = NULL;
 
-	hr = php_com_get_id_of_name(obj, name, namelen, &dispid TSRMLS_CC);
+	hr = php_com_get_id_of_name(obj, name, namelen, &dispid);
 
 	if (FAILED(hr)) {
 		winerr = php_win32_error_to_msg(hr);
 		spprintf(&msg, 0, "Unable to lookup `%s': %s", name, winerr);
 		LocalFree(winerr);
-		php_com_throw_exception(hr, msg TSRMLS_CC);
+		php_com_throw_exception(hr, msg);
 		efree(msg);
 		return FAILURE;
 	}
 
-	return php_com_do_invoke_by_id(obj, dispid, flags, v, nargs, args, 0, allow_noarg TSRMLS_CC);
+	return php_com_do_invoke_by_id(obj, dispid, flags, v, nargs, args, 0, allow_noarg);
 }
 
 /* {{{ proto string com_create_guid()
@@ -670,12 +670,12 @@ PHP_FUNCTION(com_create_guid)
 		return;
 	}
 
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	if (CoCreateGuid(&retval) == S_OK && StringFromCLSID(&retval, &guid_string) == S_OK) {
 		size_t len;
 		char *str;
 
-		str = php_com_olestring_to_string(guid_string, &len, CP_ACP TSRMLS_CC);
+		str = php_com_olestring_to_string(guid_string, &len, CP_ACP);
 		RETVAL_STRINGL(str, len);
 		// TODO: avoid reallocation ???
 		efree(str);
@@ -698,12 +698,12 @@ PHP_FUNCTION(com_event_sink)
 
 	RETVAL_FALSE;
 	
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Oo|z/",
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "Oo|z/",
 			&object, php_com_variant_class_entry, &sinkobject, &sink)) {
 		RETURN_FALSE;
 	}
 
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	obj = CDNO_FETCH(object);
 	
 	if (sink && Z_TYPE_P(sink) == IS_ARRAY) {
@@ -719,20 +719,20 @@ PHP_FUNCTION(com_event_sink)
 		dispname = Z_STRVAL_P(sink);
 	}
 	
-	typeinfo = php_com_locate_typeinfo(typelibname, obj, dispname, 1 TSRMLS_CC);
+	typeinfo = php_com_locate_typeinfo(typelibname, obj, dispname, 1);
 
 	if (typeinfo) {
 		HashTable *id_to_name;
 		
 		ALLOC_HASHTABLE(id_to_name);
 		
-		if (php_com_process_typeinfo(typeinfo, id_to_name, 0, &obj->sink_id, obj->code_page TSRMLS_CC)) {
+		if (php_com_process_typeinfo(typeinfo, id_to_name, 0, &obj->sink_id, obj->code_page)) {
 
 			/* Create the COM wrapper for this sink */
-			obj->sink_dispatch = php_com_wrapper_export_as_sink(sinkobject, &obj->sink_id, id_to_name TSRMLS_CC);
+			obj->sink_dispatch = php_com_wrapper_export_as_sink(sinkobject, &obj->sink_id, id_to_name);
 
 			/* Now hook it up to the source */
-			php_com_object_enable_event_sink(obj, TRUE TSRMLS_CC);
+			php_com_object_enable_event_sink(obj, TRUE);
 			RETVAL_TRUE;
 
 		} else {
@@ -759,12 +759,12 @@ PHP_FUNCTION(com_print_typeinfo)
 	php_com_dotnet_object *obj = NULL;
 	ITypeInfo *typeinfo;
 	
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/|s!b", &arg1, &ifacename,
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "z/|s!b", &arg1, &ifacename,
 				&ifacelen, &wantsink)) {
 		RETURN_FALSE;
 	}
 
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	if (Z_TYPE_P(arg1) == IS_OBJECT) {
 		CDNO_FETCH_VERIFY(obj, arg1);
 	} else {
@@ -772,9 +772,9 @@ PHP_FUNCTION(com_print_typeinfo)
 		typelibname = Z_STRVAL_P(arg1);
 	}
 
-	typeinfo = php_com_locate_typeinfo(typelibname, obj, ifacename, wantsink ? 1 : 0 TSRMLS_CC);
+	typeinfo = php_com_locate_typeinfo(typelibname, obj, ifacename, wantsink ? 1 : 0);
 	if (typeinfo) {
-		php_com_process_typeinfo(typeinfo, NULL, 1, NULL, obj ? obj->code_page : COMG(code_page) TSRMLS_CC);
+		php_com_process_typeinfo(typeinfo, NULL, 1, NULL, obj ? obj->code_page : COMG(code_page));
 		ITypeInfo_Release(typeinfo);
 		RETURN_TRUE;
 	} else {
@@ -792,10 +792,10 @@ PHP_FUNCTION(com_message_pump)
 	MSG msg;
 	DWORD result;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &timeoutms) == FAILURE)
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &timeoutms) == FAILURE)
 		RETURN_FALSE;
 	
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	result = MsgWaitForMultipleObjects(0, NULL, FALSE, (DWORD)timeoutms, QS_ALLINPUT);
 
 	if (result == WAIT_OBJECT_0) {
@@ -823,18 +823,18 @@ PHP_FUNCTION(com_load_typelib)
 	int codepage = COMG(code_page);
 	int cached = 0;
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &name, &namelen, &cs)) {
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "s|b", &name, &namelen, &cs)) {
 		return;
 	}
 
 	RETVAL_FALSE;
 	
-	php_com_initialize(TSRMLS_C);
-	pTL = php_com_load_typelib_via_cache(name, codepage, &cached TSRMLS_CC);
+	php_com_initialize();
+	pTL = php_com_load_typelib_via_cache(name, codepage, &cached);
 	if (pTL) {
 		if (cached) {
 			RETVAL_TRUE;
-		} else if (php_com_import_typelib(pTL, cs ? CONST_CS : 0, codepage TSRMLS_CC) == SUCCESS) {
+		} else if (php_com_import_typelib(pTL, cs ? CONST_CS : 0, codepage) == SUCCESS) {
 			RETVAL_TRUE;
 		}
 
diff --git a/ext/com_dotnet/com_dotnet.c b/ext/com_dotnet/com_dotnet.c
index ae2c6ee2f0..35f795187a 100644
--- a/ext/com_dotnet/com_dotnet.c
+++ b/ext/com_dotnet/com_dotnet.c
@@ -121,7 +121,7 @@ struct dotnet_runtime_stuff {
 	DISPID create_instance;
 };
 
-static HRESULT dotnet_init(char **p_where TSRMLS_DC)
+static HRESULT dotnet_init(char **p_where)
 {
 	HRESULT hr;
 	struct dotnet_runtime_stuff *stuff;
@@ -197,17 +197,17 @@ PHP_FUNCTION(com_dotnet_create_instance)
 	char *where = "";
 	IUnknown *unk = NULL;
 
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	stuff = (struct dotnet_runtime_stuff*)COMG(dotnet_runtime_stuff);
 	if (stuff == NULL) {
-		hr = dotnet_init(&where TSRMLS_CC);
+		hr = dotnet_init(&where);
 		if (FAILED(hr)) {
 			char buf[1024];
 			char *err = php_win32_error_to_msg(hr);
 			snprintf(buf, sizeof(buf), "Failed to init .Net runtime [%s] %s", where, err);
 			if (err)
 				LocalFree(err);
-			php_com_throw_exception(hr, buf TSRMLS_CC);
+			php_com_throw_exception(hr, buf);
 			ZEND_CTOR_MAKE_NULL();
 			return;
 		}
@@ -222,7 +222,7 @@ PHP_FUNCTION(com_dotnet_create_instance)
 			snprintf(buf, sizeof(buf), "Failed to re-init .Net domain [%s] %s", where, err);
 			if (err)
 				LocalFree(err);
-			php_com_throw_exception(hr, buf TSRMLS_CC);
+			php_com_throw_exception(hr, buf);
 			ZVAL_NULL(object);
 			return;
 		}
@@ -235,7 +235,7 @@ PHP_FUNCTION(com_dotnet_create_instance)
 			snprintf(buf, sizeof(buf), "Failed to re-init .Net domain [%s] %s", where, err);
 			if (err)
 				LocalFree(err);
-			php_com_throw_exception(hr, buf TSRMLS_CC);
+			php_com_throw_exception(hr, buf);
 			ZVAL_NULL(object);
 			return;
 		}
@@ -243,17 +243,17 @@ PHP_FUNCTION(com_dotnet_create_instance)
 
 	obj = CDNO_FETCH(object);
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l",
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "ss|l",
 			&assembly_name, &assembly_name_len,
 			&datatype_name, &datatype_name_len,
 			&obj->code_page)) {
-		php_com_throw_exception(E_INVALIDARG, "Could not create .Net object - invalid arguments!" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "Could not create .Net object - invalid arguments!");
 		ZEND_CTOR_MAKE_NULL();
 		return;
 	}
 
-	oletype = php_com_string_to_olestring(datatype_name, datatype_name_len, obj->code_page TSRMLS_CC);
-	oleassembly = php_com_string_to_olestring(assembly_name, assembly_name_len, obj->code_page TSRMLS_CC);
+	oletype = php_com_string_to_olestring(datatype_name, datatype_name_len, obj->code_page);
+	oleassembly = php_com_string_to_olestring(assembly_name, assembly_name_len, obj->code_page);
 	oletype_sys = SysAllocString(oletype);
 	oleassembly_sys = SysAllocString(oleassembly);
 	where = "CreateInstance";
@@ -313,14 +313,14 @@ PHP_FUNCTION(com_dotnet_create_instance)
 		if (err && err[0]) {
 			LocalFree(err);
 		}
-		php_com_throw_exception(hr, buf TSRMLS_CC);
+		php_com_throw_exception(hr, buf);
 		ZEND_CTOR_MAKE_NULL();
 		return;
 	}
 }
 /* }}} */
 
-void php_com_dotnet_mshutdown(TSRMLS_D)
+void php_com_dotnet_mshutdown(void)
 {
 	struct dotnet_runtime_stuff *stuff = COMG(dotnet_runtime_stuff);
 	
@@ -336,7 +336,7 @@ void php_com_dotnet_mshutdown(TSRMLS_D)
 	COMG(dotnet_runtime_stuff) = NULL;
 }
 
-void php_com_dotnet_rshutdown(TSRMLS_D)
+void php_com_dotnet_rshutdown(void)
 {
 	struct dotnet_runtime_stuff *stuff = COMG(dotnet_runtime_stuff);
 	
diff --git a/ext/com_dotnet/com_extension.c b/ext/com_dotnet/com_extension.c
index 35fda89963..4498a84e42 100644
--- a/ext/com_dotnet/com_extension.c
+++ b/ext/com_dotnet/com_extension.c
@@ -312,9 +312,9 @@ static PHP_INI_MH(OnTypeLibFileUpdate)
 			ptr--;
 		}
 
-		if ((pTL = php_com_load_typelib_via_cache(typelib_name, COMG(code_page), &cached TSRMLS_CC)) != NULL) {
+		if ((pTL = php_com_load_typelib_via_cache(typelib_name, COMG(code_page), &cached)) != NULL) {
 			if (!cached) {
-				php_com_import_typelib(pTL, mode, COMG(code_page) TSRMLS_CC);
+				php_com_import_typelib(pTL, mode, COMG(code_page));
 			}
 			ITypeLib_Release(pTL);
 		}
@@ -358,24 +358,24 @@ PHP_MINIT_FUNCTION(com_dotnet)
 	php_com_persist_minit(INIT_FUNC_ARGS_PASSTHRU);
 
 	INIT_CLASS_ENTRY(ce, "com_exception", NULL);
-	php_com_exception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
+	php_com_exception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default());
 	php_com_exception_class_entry->ce_flags |= ZEND_ACC_FINAL;
 /*	php_com_exception_class_entry->constructor->common.fn_flags |= ZEND_ACC_PROTECTED; */
 
 	INIT_CLASS_ENTRY(ce, "com_safearray_proxy", NULL);
-	php_com_saproxy_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+	php_com_saproxy_class_entry = zend_register_internal_class(&ce);
 	php_com_saproxy_class_entry->ce_flags |= ZEND_ACC_FINAL;
 /*	php_com_saproxy_class_entry->constructor->common.fn_flags |= ZEND_ACC_PROTECTED; */
 	php_com_saproxy_class_entry->get_iterator = php_com_saproxy_iter_get;
 	
 	INIT_CLASS_ENTRY(ce, "variant", NULL);
 	ce.create_object = php_com_object_new;
-	php_com_variant_class_entry = zend_register_internal_class(&ce TSRMLS_CC);
+	php_com_variant_class_entry = zend_register_internal_class(&ce);
 	php_com_variant_class_entry->get_iterator = php_com_iter_get;
 
 	INIT_CLASS_ENTRY(ce, "com", NULL);
 	ce.create_object = php_com_object_new;
-	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry TSRMLS_CC);
+	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry);
 	tmp->get_iterator = php_com_iter_get;
 
 	zend_ts_hash_init(&php_com_typelibraries, 0, NULL, php_com_typelibrary_dtor, 1);
@@ -383,7 +383,7 @@ PHP_MINIT_FUNCTION(com_dotnet)
 #if HAVE_MSCOREE_H
 	INIT_CLASS_ENTRY(ce, "dotnet", NULL);
 	ce.create_object = php_com_object_new;
-	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry TSRMLS_CC);
+	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry);
 	tmp->get_iterator = php_com_iter_get;
 #endif
 
@@ -475,7 +475,7 @@ PHP_MSHUTDOWN_FUNCTION(com_dotnet)
 	UNREGISTER_INI_ENTRIES();
 #if HAVE_MSCOREE_H
 	if (COMG(dotnet_runtime_stuff)) {
-		php_com_dotnet_mshutdown(TSRMLS_C);
+		php_com_dotnet_mshutdown();
 	}
 #endif
 
@@ -499,7 +499,7 @@ PHP_RSHUTDOWN_FUNCTION(com_dotnet)
 {
 #if HAVE_MSCOREE_H
 	if (COMG(dotnet_runtime_stuff)) {
-		php_com_dotnet_rshutdown(TSRMLS_C);
+		php_com_dotnet_rshutdown();
 	}
 #endif
 	COMG(rshutdown_started) = 1;
diff --git a/ext/com_dotnet/com_handlers.c b/ext/com_dotnet/com_handlers.c
index 8b721393fd..60830dc599 100644
--- a/ext/com_dotnet/com_handlers.c
+++ b/ext/com_dotnet/com_handlers.c
@@ -29,7 +29,7 @@
 #include "php_com_dotnet_internal.h"
 #include "Zend/zend_exceptions.h"
 
-static zval *com_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv TSRMLS_DC)
+static zval *com_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv)
 {
 	php_com_dotnet_object *obj;
 	VARIANT v;
@@ -45,22 +45,22 @@ static zval *com_property_read(zval *object, zval *member, int type, void **cahc
 		convert_to_string_ex(member);
 
 		res = php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRLEN_P(member),
-				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1 TSRMLS_CC);
+				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1);
 
 		if (res == SUCCESS) {
-			php_com_zval_from_variant(rv, &v, obj->code_page TSRMLS_CC);
+			php_com_zval_from_variant(rv, &v, obj->code_page);
 			VariantClear(&v);
 		} else if (res == DISP_E_BADPARAMCOUNT) {
-			php_com_saproxy_create(object, rv, member TSRMLS_CC);
+			php_com_saproxy_create(object, rv, member);
 		}
 	} else {
-		php_com_throw_exception(E_INVALIDARG, "this variant has no properties" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "this variant has no properties");
 	}
 
 	return rv;
 }
 
-static void com_property_write(zval *object, zval *member, zval *value, void **cache_slot TSRMLS_DC)
+static void com_property_write(zval *object, zval *member, zval *value, void **cache_slot)
 {
 	php_com_dotnet_object *obj;
 	VARIANT v;
@@ -72,15 +72,15 @@ static void com_property_write(zval *object, zval *member, zval *value, void **c
 
 		convert_to_string_ex(member);
 		if (SUCCESS == php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRLEN_P(member),
-				DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &v, 1, value, 0 TSRMLS_CC)) {
+				DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &v, 1, value, 0)) {
 			VariantClear(&v);
 		}
 	} else {
-		php_com_throw_exception(E_INVALIDARG, "this variant has no properties" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "this variant has no properties");
 	}
 }
 
-static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv TSRMLS_DC)
+static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv)
 {
 	php_com_dotnet_object *obj;
 	VARIANT v;
@@ -93,30 +93,30 @@ static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv T
 		VariantInit(&v);
 
 		if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE,
-				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 1, offset, 0, 0 TSRMLS_CC)) {
-			php_com_zval_from_variant(rv, &v, obj->code_page TSRMLS_CC);
+				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 1, offset, 0, 0)) {
+			php_com_zval_from_variant(rv, &v, obj->code_page);
 			VariantClear(&v);
 		}
 	} else if (V_ISARRAY(&obj->v)) {
 		convert_to_long(offset);
 
 		if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) {	
-			if (php_com_safearray_get_elem(&obj->v, &v, (LONG)Z_LVAL_P(offset) TSRMLS_CC)) {
-				php_com_wrap_variant(rv, &v, obj->code_page TSRMLS_CC);
+			if (php_com_safearray_get_elem(&obj->v, &v, (LONG)Z_LVAL_P(offset))) {
+				php_com_wrap_variant(rv, &v, obj->code_page);
 				VariantClear(&v);
 			}
 		} else {
-			php_com_saproxy_create(object, rv, offset TSRMLS_CC);
+			php_com_saproxy_create(object, rv, offset);
 		}
 
 	} else {
-		php_com_throw_exception(E_INVALIDARG, "this variant is not an array type" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "this variant is not an array type");
 	}
 
 	return rv;
 }
 
-static void com_write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC)
+static void com_write_dimension(zval *object, zval *offset, zval *value)
 {
 	php_com_dotnet_object *obj;
 	zval args[2];
@@ -132,7 +132,7 @@ static void com_write_dimension(zval *object, zval *offset, zval *value TSRMLS_D
 		VariantInit(&v);
 
 		if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE,
-				DISPATCH_METHOD|DISPATCH_PROPERTYPUT, &v, 2, args, 0, 0 TSRMLS_CC)) {
+				DISPATCH_METHOD|DISPATCH_PROPERTYPUT, &v, 2, args, 0, 0)) {
 			VariantClear(&v);
 		}
 	} else if (V_ISARRAY(&obj->v)) {
@@ -148,7 +148,7 @@ static void com_write_dimension(zval *object, zval *offset, zval *value TSRMLS_D
 			indices = (LONG)Z_LVAL_P(offset);
 
 			VariantInit(&v);
-			php_com_variant_from_zval(&v, value, obj->code_page TSRMLS_CC);
+			php_com_variant_from_zval(&v, value, obj->code_page);
 
 			if (V_VT(&v) != vt) {
 				VariantChangeType(&v, &v, 0, vt);
@@ -163,32 +163,32 @@ static void com_write_dimension(zval *object, zval *offset, zval *value TSRMLS_D
 			VariantClear(&v);
 
 			if (FAILED(res)) {
-				php_com_throw_exception(res, NULL TSRMLS_CC);
+				php_com_throw_exception(res, NULL);
 			}
 
 		} else {
-			php_com_throw_exception(DISP_E_BADINDEX, "this variant has multiple dimensions; you can't set a new value without specifying *all* dimensions" TSRMLS_CC);
+			php_com_throw_exception(DISP_E_BADINDEX, "this variant has multiple dimensions; you can't set a new value without specifying *all* dimensions");
 		}
 
 	} else {
-		php_com_throw_exception(E_INVALIDARG, "this variant is not an array type" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "this variant is not an array type");
 	}
 }
 
 #if 0
-static void com_object_set(zval **property, zval *value TSRMLS_DC)
+static void com_object_set(zval **property, zval *value)
 {
 	/* Not yet implemented in the engine */
 }
 
-static zval *com_object_get(zval *property TSRMLS_DC)
+static zval *com_object_get(zval *property)
 {
 	/* Not yet implemented in the engine */
 	return NULL;
 }
 #endif
 
-static int com_property_exists(zval *object, zval *member, int check_empty, void **cache_slot TSRMLS_DC)
+static int com_property_exists(zval *object, zval *member, int check_empty, void **cache_slot)
 {
 	DISPID dispid;
 	php_com_dotnet_object *obj;
@@ -197,7 +197,7 @@ static int com_property_exists(zval *object, zval *member, int check_empty, void
 
 	if (V_VT(&obj->v) == VT_DISPATCH) {
 		convert_to_string_ex(member);
-		if (SUCCEEDED(php_com_get_id_of_name(obj, Z_STRVAL_P(member), Z_STRLEN_P(member), &dispid TSRMLS_CC))) {
+		if (SUCCEEDED(php_com_get_id_of_name(obj, Z_STRVAL_P(member), Z_STRLEN_P(member), &dispid))) {
 			/* TODO: distinguish between property and method! */
 			return 1;
 		}
@@ -208,23 +208,23 @@ static int com_property_exists(zval *object, zval *member, int check_empty, void
 	return 0;
 }
 
-static int com_dimension_exists(zval *object, zval *member, int check_empty TSRMLS_DC)
+static int com_dimension_exists(zval *object, zval *member, int check_empty)
 {
-	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Operation not yet supported on a COM object");
+	php_error_docref(NULL, E_WARNING, "Operation not yet supported on a COM object");
 	return 0;
 }
 
-static void com_property_delete(zval *object, zval *member, void **cache_slot TSRMLS_DC)
+static void com_property_delete(zval *object, zval *member, void **cache_slot)
 {
-	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a COM object");
+	php_error_docref(NULL, E_WARNING, "Cannot delete properties from a COM object");
 }
 
-static void com_dimension_delete(zval *object, zval *offset TSRMLS_DC)
+static void com_dimension_delete(zval *object, zval *offset)
 {
-	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a COM object");
+	php_error_docref(NULL, E_WARNING, "Cannot delete properties from a COM object");
 }
 
-static HashTable *com_properties_get(zval *object TSRMLS_DC)
+static HashTable *com_properties_get(zval *object)
 {
 	/* TODO: use type-info to get all the names and values ?
 	 * DANGER: if we do that, there is a strong possibility for
@@ -255,7 +255,7 @@ static PHP_FUNCTION(com_method_handler)
 			INTERNAL_FUNCTION_PARAM_PASSTHRU);
 }
 
-static union _zend_function *com_method_get(zend_object **object_ptr, zend_string *name, const zval *key TSRMLS_DC)
+static union _zend_function *com_method_get(zend_object **object_ptr, zend_string *name, const zval *key)
 {
 	zend_internal_function f, *fptr = NULL;
 	union _zend_function *func;
@@ -266,7 +266,7 @@ static union _zend_function *com_method_get(zend_object **object_ptr, zend_strin
 		return NULL;
 	}
 
-	if (FAILED(php_com_get_id_of_name(obj, name->val, name->len, &dummy TSRMLS_CC))) {
+	if (FAILED(php_com_get_id_of_name(obj, name->val, name->len, &dummy))) {
 		return NULL;
 	}
 
@@ -293,7 +293,7 @@ static union _zend_function *com_method_get(zend_object **object_ptr, zend_strin
 			int i;
 
 			if (SUCCEEDED(ITypeInfo_GetTypeComp(obj->typeinfo, &comp))) {
-				olename = php_com_string_to_olestring(name->val, name->len, obj->code_page TSRMLS_CC);
+				olename = php_com_string_to_olestring(name->val, name->len, obj->code_page);
 				lhash = LHashValOfNameSys(SYS_WIN32, LOCALE_SYSTEM_DEFAULT, olename);
 
 				if (SUCCEEDED(ITypeComp_Bind(comp, olename, lhash, INVOKE_FUNC, &TI, &kind, &bindptr))) {
@@ -378,8 +378,8 @@ static int com_call_method(zend_string *method, zend_object *object, INTERNAL_FU
 
 	VariantInit(&v);
 
-	if (SUCCESS == php_com_do_invoke_byref(obj, (zend_internal_function*)EX(func), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, nargs, args TSRMLS_CC)) {
-		php_com_zval_from_variant(return_value, &v, obj->code_page TSRMLS_CC);
+	if (SUCCESS == php_com_do_invoke_byref(obj, (zend_internal_function*)EX(func), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, nargs, args)) {
+		php_com_zval_from_variant(return_value, &v, obj->code_page);
 		ret = SUCCESS;
 		VariantClear(&v);
 	}
@@ -391,7 +391,7 @@ static int com_call_method(zend_string *method, zend_object *object, INTERNAL_FU
 	return ret;
 }
 
-static union _zend_function *com_constructor_get(zend_object *object TSRMLS_DC)
+static union _zend_function *com_constructor_get(zend_object *object)
 {
 	php_com_dotnet_object *obj = (php_com_dotnet_object *) object;
 	static zend_internal_function c, d, v;
@@ -423,7 +423,7 @@ static union _zend_function *com_constructor_get(zend_object *object TSRMLS_DC)
 	}
 }
 
-static zend_string* com_class_name_get(const zend_object *object TSRMLS_DC)
+static zend_string* com_class_name_get(const zend_object *object)
 {
 	php_com_dotnet_object *obj = (php_com_dotnet_object *)object;
 
@@ -431,7 +431,7 @@ static zend_string* com_class_name_get(const zend_object *object TSRMLS_DC)
 }
 
 /* This compares two variants for equality */
-static int com_objects_compare(zval *object1, zval *object2 TSRMLS_DC)
+static int com_objects_compare(zval *object1, zval *object2)
 {
 	php_com_dotnet_object *obja, *objb;
 	int ret;
@@ -463,7 +463,7 @@ static int com_objects_compare(zval *object1, zval *object2 TSRMLS_DC)
 	return ret;
 }
 
-static int com_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
+static int com_object_cast(zval *readobj, zval *writeobj, int type)
 {
 	php_com_dotnet_object *obj;
 	VARIANT v;
@@ -476,7 +476,7 @@ static int com_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 
 	if (V_VT(&obj->v) == VT_DISPATCH) {
 		if (SUCCESS != php_com_do_invoke_by_id(obj, DISPID_VALUE,
-				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1, 0 TSRMLS_CC)) {
+				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1, 0)) {
 			VariantCopy(&v, &obj->v);
 		}
 	} else {
@@ -506,7 +506,7 @@ static int com_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 	}
 
 	if (SUCCEEDED(res)) {
-		php_com_zval_from_variant(writeobj, &v, obj->code_page TSRMLS_CC);
+		php_com_zval_from_variant(writeobj, &v, obj->code_page);
 	}
 
 	VariantClear(&v);
@@ -515,10 +515,10 @@ static int com_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 		return SUCCESS;
 	}
 
-	return zend_std_cast_object_tostring(readobj, writeobj, type TSRMLS_CC);
+	return zend_std_cast_object_tostring(readobj, writeobj, type);
 }
 
-static int com_object_count(zval *object, zend_long *count TSRMLS_DC)
+static int com_object_count(zval *object, zend_long *count)
 {
 	php_com_dotnet_object *obj;
 	LONG ubound = 0, lbound = 0;
@@ -566,7 +566,7 @@ zend_object_handlers php_com_object_handlers = {
 	NULL,									/* get_gc */
 };
 
-void php_com_object_enable_event_sink(php_com_dotnet_object *obj, int enable TSRMLS_DC)
+void php_com_object_enable_event_sink(php_com_dotnet_object *obj, int enable)
 {
 	if (obj->sink_dispatch) {
 		IConnectionPointContainer *cont;
@@ -590,7 +590,7 @@ void php_com_object_enable_event_sink(php_com_dotnet_object *obj, int enable TSR
 	}
 }
 
-void php_com_object_free_storage(zend_object *object TSRMLS_DC)
+void php_com_object_free_storage(zend_object *object)
 {
 	php_com_dotnet_object *obj = (php_com_dotnet_object*)object;
 
@@ -600,7 +600,7 @@ void php_com_object_free_storage(zend_object *object TSRMLS_DC)
 	}
 
 	if (obj->sink_dispatch) {
-		php_com_object_enable_event_sink(obj, FALSE TSRMLS_CC);
+		php_com_object_enable_event_sink(obj, FALSE);
 		IDispatch_Release(obj->sink_dispatch);
 		obj->sink_dispatch = NULL;
 	}
@@ -617,7 +617,7 @@ void php_com_object_free_storage(zend_object *object TSRMLS_DC)
 	}
 }
 
-zend_object* php_com_object_clone(zval *object TSRMLS_DC)
+zend_object* php_com_object_clone(zval *object)
 {
 	php_com_dotnet_object *cloneobj, *origobject;
 
@@ -641,11 +641,11 @@ zend_object* php_com_object_clone(zval *object TSRMLS_DC)
 	return (zend_object*)cloneobj;
 }
 
-zend_object* php_com_object_new(zend_class_entry *ce TSRMLS_DC)
+zend_object* php_com_object_new(zend_class_entry *ce)
 {
 	php_com_dotnet_object *obj;
 
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	obj = emalloc(sizeof(*obj));
 	memset(obj, 0, sizeof(*obj));
 
@@ -653,7 +653,7 @@ zend_object* php_com_object_new(zend_class_entry *ce TSRMLS_DC)
 	obj->code_page = CP_ACP;
 	obj->ce = ce;
 
-	zend_object_std_init(&obj->zo, ce TSRMLS_CC);
+	zend_object_std_init(&obj->zo, ce);
 	obj->zo.handlers = &php_com_object_handlers;
 
 	return (zend_object*)obj;
diff --git a/ext/com_dotnet/com_iterator.c b/ext/com_dotnet/com_iterator.c
index a7614673f8..20cf6bfc19 100644
--- a/ext/com_dotnet/com_iterator.c
+++ b/ext/com_dotnet/com_iterator.c
@@ -41,7 +41,7 @@ struct php_com_iterator {
 	zval zdata;
 };
 
-static void com_iter_dtor(zend_object_iterator *iter TSRMLS_DC)
+static void com_iter_dtor(zend_object_iterator *iter)
 {
 	struct php_com_iterator *I = (struct php_com_iterator*)Z_PTR(iter->data);
 	
@@ -53,7 +53,7 @@ static void com_iter_dtor(zend_object_iterator *iter TSRMLS_DC)
 	zval_ptr_dtor(&I->zdata);
 }
 
-static int com_iter_valid(zend_object_iterator *iter TSRMLS_DC)
+static int com_iter_valid(zend_object_iterator *iter)
 {
 	struct php_com_iterator *I = (struct php_com_iterator*)Z_PTR(iter->data);
 
@@ -64,14 +64,14 @@ static int com_iter_valid(zend_object_iterator *iter TSRMLS_DC)
 	return FAILURE;
 }
 
-static zval* com_iter_get_data(zend_object_iterator *iter TSRMLS_DC)
+static zval* com_iter_get_data(zend_object_iterator *iter)
 {
 	struct php_com_iterator *I = (struct php_com_iterator*)Z_PTR(iter->data);
 
 	return &I->zdata;
 }
 
-static void com_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
+static void com_iter_get_key(zend_object_iterator *iter, zval *key)
 {
 	struct php_com_iterator *I = (struct php_com_iterator*)Z_PTR(iter->data);
 
@@ -82,7 +82,7 @@ static void com_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
 	}
 }
 
-static int com_iter_move_forwards(zend_object_iterator *iter TSRMLS_DC)
+static int com_iter_move_forwards(zend_object_iterator *iter)
 {
 	struct php_com_iterator *I = (struct php_com_iterator*)Z_PTR(iter->data);
 	unsigned long n_fetched;
@@ -112,15 +112,15 @@ static int com_iter_move_forwards(zend_object_iterator *iter TSRMLS_DC)
 			return FAILURE;
 		}
 		I->key++;
-		if (php_com_safearray_get_elem(&I->safe_array, &I->v, (LONG)I->key TSRMLS_CC) == 0) {
+		if (php_com_safearray_get_elem(&I->safe_array, &I->v, (LONG)I->key) == 0) {
 			I->key = (ulong)-1;
 			return FAILURE;
 		}
 	}
 
 	ZVAL_NULL(&ptr);
-	php_com_zval_from_variant(&ptr, &I->v, I->code_page TSRMLS_CC);
-	/* php_com_wrap_variant(ptr, &I->v, I->code_page TSRMLS_CC); */
+	php_com_zval_from_variant(&ptr, &I->v, I->code_page);
+	/* php_com_wrap_variant(ptr, &I->v, I->code_page); */
 	ZVAL_COPY_VALUE(&I->zdata, &ptr);
 	return SUCCESS;
 }
@@ -135,7 +135,7 @@ static zend_object_iterator_funcs com_iter_funcs = {
 	NULL
 };
 
-zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
+zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref)
 {
 	php_com_dotnet_object *obj;
 	struct php_com_iterator *I;
@@ -152,7 +152,7 @@ zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int b
 	obj = CDNO_FETCH(object);
 
 	if (V_VT(&obj->v) != VT_DISPATCH && !V_ISARRAY(&obj->v)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant is not an object or array VT=%d", V_VT(&obj->v));
+		php_error_docref(NULL, E_WARNING, "variant is not an object or array VT=%d", V_VT(&obj->v));
 		return NULL;
 	}
 
@@ -160,7 +160,7 @@ zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int b
 	VariantInit(&v);	
 
 	I = (struct php_com_iterator*)ecalloc(1, sizeof(*I));
-	zend_iterator_init(&I->iter TSRMLS_CC);
+	zend_iterator_init(&I->iter);
 	I->iter.funcs = &com_iter_funcs;
 	Z_PTR(I->iter.data) = I;
 	I->code_page = obj->code_page;
@@ -175,7 +175,7 @@ zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int b
 		dims = SafeArrayGetDim(V_ARRAY(&obj->v));
 
 		if (dims != 1) {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING,
+			php_error_docref(NULL, E_WARNING,
 				   "Can only handle single dimension variant arrays (this array has %d)", dims);
 			goto fail;
 		}
@@ -189,10 +189,10 @@ zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int b
 		SafeArrayGetUBound(V_ARRAY(&I->safe_array), 1, &I->sa_max);
 
 		/* pre-fetch the element */
-		if (php_com_safearray_get_elem(&I->safe_array, &I->v, bound TSRMLS_CC)) {
+		if (php_com_safearray_get_elem(&I->safe_array, &I->v, bound)) {
 			I->key = bound;
 			ZVAL_NULL(&ptr);
-			php_com_zval_from_variant(&ptr, &I->v, I->code_page TSRMLS_CC);
+			php_com_zval_from_variant(&ptr, &I->v, I->code_page);
 			ZVAL_COPY_VALUE(&I->zdata, &ptr);
 		} else {
 			I->key = (ulong)-1;
@@ -226,7 +226,7 @@ zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int b
 			/* indicate that we have element 0 */
 			I->key = 0;
 			ZVAL_NULL(&ptr);
-			php_com_zval_from_variant(&ptr, &I->v, I->code_page TSRMLS_CC);
+			php_com_zval_from_variant(&ptr, &I->v, I->code_page);
 			ZVAL_COPY_VALUE(&I->zdata, &ptr);
 		} else {
 			/* indicate that there are no more items */
diff --git a/ext/com_dotnet/com_misc.c b/ext/com_dotnet/com_misc.c
index f0b21ff014..f776cb4d32 100644
--- a/ext/com_dotnet/com_misc.c
+++ b/ext/com_dotnet/com_misc.c
@@ -29,7 +29,7 @@
 #include "php_com_dotnet_internal.h"
 #include "Zend/zend_exceptions.h"
 
-void php_com_throw_exception(HRESULT code, char *message TSRMLS_DC)
+void php_com_throw_exception(HRESULT code, char *message)
 {
 	int free_msg = 0;
 	if (message == NULL) {
@@ -37,9 +37,9 @@ void php_com_throw_exception(HRESULT code, char *message TSRMLS_DC)
 		free_msg = 1;
 	}
 #if SIZEOF_ZEND_LONG == 8
-	zend_throw_exception(php_com_exception_class_entry, message, (zend_long)(uint32_t)code TSRMLS_CC);
+	zend_throw_exception(php_com_exception_class_entry, message, (zend_long)(uint32_t)code);
 #else
-	zend_throw_exception(php_com_exception_class_entry, message, (zend_long)code TSRMLS_CC);
+	zend_throw_exception(php_com_exception_class_entry, message, (zend_long)code);
 #endif
 	if (free_msg) {
 		LocalFree(message);
@@ -47,7 +47,7 @@ void php_com_throw_exception(HRESULT code, char *message TSRMLS_DC)
 }
 
 PHP_COM_DOTNET_API void php_com_wrap_dispatch(zval *z, IDispatch *disp,
-		int codepage TSRMLS_DC)
+		int codepage)
 {
 	php_com_dotnet_object *obj;
 
@@ -64,13 +64,13 @@ PHP_COM_DOTNET_API void php_com_wrap_dispatch(zval *z, IDispatch *disp,
 	IDispatch_AddRef(V_DISPATCH(&obj->v));
 	IDispatch_GetTypeInfo(V_DISPATCH(&obj->v), 0, LANG_NEUTRAL, &obj->typeinfo);
 
-	zend_object_std_init(&obj->zo, php_com_variant_class_entry TSRMLS_CC);
+	zend_object_std_init(&obj->zo, php_com_variant_class_entry);
 	obj->zo.handlers = &php_com_object_handlers;
 	ZVAL_OBJ(z, &obj->zo);
 }
 
 PHP_COM_DOTNET_API void php_com_wrap_variant(zval *z, VARIANT *v,
-		int codepage TSRMLS_DC)
+		int codepage)
 {
 	php_com_dotnet_object *obj;
 
@@ -88,14 +88,14 @@ PHP_COM_DOTNET_API void php_com_wrap_variant(zval *z, VARIANT *v,
 		IDispatch_GetTypeInfo(V_DISPATCH(&obj->v), 0, LANG_NEUTRAL, &obj->typeinfo);
 	}
 
-	zend_object_std_init(&obj->zo, php_com_variant_class_entry TSRMLS_CC);
+	zend_object_std_init(&obj->zo, php_com_variant_class_entry);
 	obj->zo.handlers = &php_com_object_handlers;
 	ZVAL_OBJ(z, &obj->zo);
 }
 
 /* this is a convenience function for fetching a particular
  * element from a (possibly multi-dimensional) safe array */
-PHP_COM_DOTNET_API int php_com_safearray_get_elem(VARIANT *array, VARIANT *dest, LONG dim1 TSRMLS_DC)
+PHP_COM_DOTNET_API int php_com_safearray_get_elem(VARIANT *array, VARIANT *dest, LONG dim1)
 {
 	UINT dims;
 	LONG lbound, ubound;
@@ -109,7 +109,7 @@ PHP_COM_DOTNET_API int php_com_safearray_get_elem(VARIANT *array, VARIANT *dest,
 	dims = SafeArrayGetDim(V_ARRAY(array));
 
 	if (dims != 1) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING,
+		php_error_docref(NULL, E_WARNING,
 			   "Can only handle single dimension variant arrays (this array has %d)", dims);
 		return 0;
 	}
@@ -124,7 +124,7 @@ PHP_COM_DOTNET_API int php_com_safearray_get_elem(VARIANT *array, VARIANT *dest,
 	
 	/* check bounds */
 	if (dim1 < lbound || dim1 > ubound) {
-		php_com_throw_exception(DISP_E_BADINDEX, "index out of bounds" TSRMLS_CC);
+		php_com_throw_exception(DISP_E_BADINDEX, "index out of bounds");
 		return 0;
 	}
 	
diff --git a/ext/com_dotnet/com_olechar.c b/ext/com_dotnet/com_olechar.c
index 2e0b558288..30389ffb8c 100644
--- a/ext/com_dotnet/com_olechar.c
+++ b/ext/com_dotnet/com_olechar.c
@@ -30,7 +30,7 @@
 #include "php_com_dotnet_internal.h"
 
 
-PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string, size_t string_len, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string, size_t string_len, int codepage)
 {
 	OLECHAR *olestring = NULL;
 	DWORD flags = codepage == CP_UTF8 ? 0 : MB_PRECOMPOSED | MB_ERR_INVALID_CHARS;
@@ -62,7 +62,7 @@ PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string, size_t str
 	if (!ok) {
 		char *msg = php_win32_error_to_msg(GetLastError());
 
-		php_error_docref(NULL TSRMLS_CC, E_WARNING,
+		php_error_docref(NULL, E_WARNING,
 			"Could not convert string to unicode: `%s'", msg);
 
 		LocalFree(msg);
@@ -71,7 +71,7 @@ PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string, size_t str
 	return olestring;
 }
 
-PHP_COM_DOTNET_API char *php_com_olestring_to_string(OLECHAR *olestring, size_t *string_len, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API char *php_com_olestring_to_string(OLECHAR *olestring, size_t *string_len, int codepage)
 {
 	char *string;
 	uint length = 0;
@@ -93,7 +93,7 @@ PHP_COM_DOTNET_API char *php_com_olestring_to_string(OLECHAR *olestring, size_t
 	if (!ok) {
 		char *msg = php_win32_error_to_msg(GetLastError());
 
-		php_error_docref(NULL TSRMLS_CC, E_WARNING,
+		php_error_docref(NULL, E_WARNING,
 			"Could not convert string from unicode: `%s'", msg);
 
 		LocalFree(msg);
diff --git a/ext/com_dotnet/com_persist.c b/ext/com_dotnet/com_persist.c
index dbe8b45300..eec1389ade 100644
--- a/ext/com_dotnet/com_persist.c
+++ b/ext/com_dotnet/com_persist.c
@@ -45,12 +45,12 @@ typedef struct {
 } php_istream;
 
 static int le_istream;
-static void istream_destructor(php_istream *stm TSRMLS_DC);
+static void istream_destructor(php_istream *stm);
 
-static void istream_dtor(zend_resource *rsrc TSRMLS_DC)
+static void istream_dtor(zend_resource *rsrc)
 {
 	php_istream *stm = (php_istream *)rsrc->ptr;
-	istream_destructor(stm TSRMLS_CC);
+	istream_destructor(stm);
 }
 
 #define FETCH_STM()	\
@@ -249,7 +249,7 @@ static struct IStreamVtbl php_istream_vtbl = {
 	stm_clone
 };
 
-static void istream_destructor(php_istream *stm TSRMLS_DC)
+static void istream_destructor(php_istream *stm)
 {
 	if (stm->res) {
 		zend_resource *res = stm->res;
@@ -268,7 +268,7 @@ static void istream_destructor(php_istream *stm TSRMLS_DC)
 }
 /* }}} */
 
-PHP_COM_DOTNET_API IStream *php_com_wrapper_export_stream(php_stream *stream TSRMLS_DC)
+PHP_COM_DOTNET_API IStream *php_com_wrapper_export_stream(php_stream *stream)
 {
 	php_istream *stm = (php_istream*)CoTaskMemAlloc(sizeof(*stm));
 	zval *tmp;
@@ -283,7 +283,7 @@ PHP_COM_DOTNET_API IStream *php_com_wrapper_export_stream(php_stream *stream TSR
 	stm->stream = stream;
 
 	GC_REFCOUNT(stream->res)++;
-	tmp = zend_list_insert(stm, le_istream TSRMLS_CC);
+	tmp = zend_list_insert(stm, le_istream);
 	stm->res = Z_RES_P(tmp);
 
 	return (IStream*)stm;
@@ -295,7 +295,7 @@ PHP_COM_DOTNET_API IStream *php_com_wrapper_export_stream(php_stream *stream TSR
 	
 #define CPH_FETCH()				php_com_persist_helper *helper = (php_com_persist_helper*)Z_OBJ_P(getThis());
 
-#define CPH_NO_OBJ()			if (helper->unk == NULL) { php_com_throw_exception(E_INVALIDARG, "No COM object is associated with this helper instance" TSRMLS_CC); return; }
+#define CPH_NO_OBJ()			if (helper->unk == NULL) { php_com_throw_exception(E_INVALIDARG, "No COM object is associated with this helper instance"); return; }
 
 typedef struct {
 	zend_object			std;
@@ -351,7 +351,7 @@ CPH_METHOD(GetCurFileName)
 		if (res == S_OK) {
 			size_t len;
 			char *str = php_com_olestring_to_string(olename,
-				   &len, helper->codepage TSRMLS_CC);
+				   &len, helper->codepage);
 			RETVAL_STRINGL(str, len);
 			// TODO: avoid reallocarion???
 			efree(str);
@@ -361,9 +361,9 @@ CPH_METHOD(GetCurFileName)
 			CoTaskMemFree(olename);
 			RETURN_FALSE;
 		}
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 	} else {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 	}
 }
 /* }}} */
@@ -384,24 +384,24 @@ CPH_METHOD(SaveToFile)
 
 	res = get_persist_file(helper);
 	if (helper->ipf) {
-		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p!|b",
+		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "p!|b",
 					&filename, &filename_len, &remember)) {
-			php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
+			php_com_throw_exception(E_INVALIDARG, "Invalid arguments");
 			return;
 		}
 
 		if (filename) {
-			fullpath = expand_filepath(filename, NULL TSRMLS_CC);
+			fullpath = expand_filepath(filename, NULL);
 			if (!fullpath) {
 				RETURN_FALSE;
 			}
 	
-			if (php_check_open_basedir(fullpath TSRMLS_CC)) {
+			if (php_check_open_basedir(fullpath)) {
 				efree(fullpath);
 				RETURN_FALSE;
 			}
 
-			olefilename = php_com_string_to_olestring(filename, strlen(fullpath), helper->codepage TSRMLS_CC);
+			olefilename = php_com_string_to_olestring(filename, strlen(fullpath), helper->codepage);
 			efree(fullpath);
 		}
 		res = IPersistFile_Save(helper->ipf, olefilename, remember);
@@ -423,11 +423,11 @@ CPH_METHOD(SaveToFile)
 		}
 
 		if (FAILED(res)) {
-			php_com_throw_exception(res, NULL TSRMLS_CC);
+			php_com_throw_exception(res, NULL);
 		}
 
 	} else {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 	}
 }
 /* }}} */
@@ -448,33 +448,33 @@ CPH_METHOD(LoadFromFile)
 	res = get_persist_file(helper);
 	if (helper->ipf) {
 
-		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|l",
+		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "p|l",
 					&filename, &filename_len, &flags)) {
-			php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
+			php_com_throw_exception(E_INVALIDARG, "Invalid arguments");
 			return;
 		}
 
-		if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) {
+		if (!(fullpath = expand_filepath(filename, NULL))) {
 			RETURN_FALSE;
 		}
 
-		if (php_check_open_basedir(fullpath TSRMLS_CC)) {
+		if (php_check_open_basedir(fullpath)) {
 			efree(fullpath);
 			RETURN_FALSE;
 		}
 
-		olefilename = php_com_string_to_olestring(fullpath, strlen(fullpath), helper->codepage TSRMLS_CC);
+		olefilename = php_com_string_to_olestring(fullpath, strlen(fullpath), helper->codepage);
 		efree(fullpath);
 			
 		res = IPersistFile_Load(helper->ipf, olefilename, (DWORD)flags);
 		efree(olefilename);
 
 		if (FAILED(res)) {
-			php_com_throw_exception(res, NULL TSRMLS_CC);
+			php_com_throw_exception(res, NULL);
 		}
 		
 	} else {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 	}
 }
 /* }}} */
@@ -497,13 +497,13 @@ CPH_METHOD(GetMaxStreamSize)
 		if (helper->ips) {
 			res = IPersistStream_GetSizeMax(helper->ips, &size);
 		} else {
-			php_com_throw_exception(res, NULL TSRMLS_CC);
+			php_com_throw_exception(res, NULL);
 			return;
 		}
 	}
 
 	if (res != S_OK) {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 	} else {
 		/* TODO: handle 64 bit properly */
 		RETURN_LONG((zend_long)size.QuadPart);
@@ -525,12 +525,12 @@ CPH_METHOD(InitNew)
 		res = IPersistStreamInit_InitNew(helper->ipsi);
 
 		if (res != S_OK) {
-			php_com_throw_exception(res, NULL TSRMLS_CC);
+			php_com_throw_exception(res, NULL);
 		} else {
 			RETURN_TRUE;
 		}
 	} else {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 	}
 }
 /* }}} */
@@ -545,21 +545,21 @@ CPH_METHOD(LoadFromStream)
 	HRESULT res;
 	CPH_FETCH();
 	
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstm)) {
-		php_com_throw_exception(E_INVALIDARG, "invalid arguments" TSRMLS_CC);
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "r", &zstm)) {
+		php_com_throw_exception(E_INVALIDARG, "invalid arguments");
 		return;
 	}
 
 	php_stream_from_zval_no_verify(stream, zstm);
 	
 	if (stream == NULL) {
-		php_com_throw_exception(E_INVALIDARG, "expected a stream" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "expected a stream");
 		return;
 	}
 
-	stm = php_com_wrapper_export_stream(stream TSRMLS_CC);
+	stm = php_com_wrapper_export_stream(stream);
 	if (stm == NULL) {
-		php_com_throw_exception(E_UNEXPECTED, "failed to wrap stream" TSRMLS_CC);
+		php_com_throw_exception(E_UNEXPECTED, "failed to wrap stream");
 		return;
 	}
 	
@@ -573,7 +573,7 @@ CPH_METHOD(LoadFromStream)
 		res = OleLoadFromStream(stm, &IID_IDispatch, &disp);
 
 		if (SUCCEEDED(res)) {
-			php_com_wrap_dispatch(return_value, disp, COMG(code_page) TSRMLS_CC);	
+			php_com_wrap_dispatch(return_value, disp, COMG(code_page));	
 		}
 	} else {
 		res = get_persist_stream_init(helper);
@@ -589,7 +589,7 @@ CPH_METHOD(LoadFromStream)
 	IStream_Release(stm);
 
 	if (FAILED(res)) {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 		RETURN_NULL();
 	}
 }
@@ -607,21 +607,21 @@ CPH_METHOD(SaveToStream)
 	
 	CPH_NO_OBJ();
 	
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstm)) {
-		php_com_throw_exception(E_INVALIDARG, "invalid arguments" TSRMLS_CC);
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "r", &zstm)) {
+		php_com_throw_exception(E_INVALIDARG, "invalid arguments");
 		return;
 	}
 
 	php_stream_from_zval_no_verify(stream, zstm);
 	
 	if (stream == NULL) {
-		php_com_throw_exception(E_INVALIDARG, "expected a stream" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "expected a stream");
 		return;
 	}
 
-	stm = php_com_wrapper_export_stream(stream TSRMLS_CC);
+	stm = php_com_wrapper_export_stream(stream);
 	if (stm == NULL) {
-		php_com_throw_exception(E_UNEXPECTED, "failed to wrap stream" TSRMLS_CC);
+		php_com_throw_exception(E_UNEXPECTED, "failed to wrap stream");
 		return;
 	}
 	
@@ -638,7 +638,7 @@ CPH_METHOD(SaveToStream)
 	IStream_Release(stm);
 
 	if (FAILED(res)) {
-		php_com_throw_exception(res, NULL TSRMLS_CC);
+		php_com_throw_exception(res, NULL);
 		return;
 	}
 
@@ -654,9 +654,9 @@ CPH_METHOD(__construct)
 	zval *zobj = NULL;
 	CPH_FETCH();
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|O!",
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "|O!",
 				&zobj, php_com_variant_class_entry)) {
-		php_com_throw_exception(E_INVALIDARG, "invalid arguments" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "invalid arguments");
 		return;
 	}
 
@@ -667,7 +667,7 @@ CPH_METHOD(__construct)
 	obj = CDNO_FETCH(zobj);
 
 	if (V_VT(&obj->v) != VT_DISPATCH || V_DISPATCH(&obj->v) == NULL) {
-		php_com_throw_exception(E_INVALIDARG, "parameter must represent an IDispatch COM object" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "parameter must represent an IDispatch COM object");
 		return;
 	}
 
@@ -693,7 +693,7 @@ static const zend_function_entry com_persist_helper_methods[] = {
 	PHP_FE_END
 };
 
-static void helper_free_storage(zend_object *obj TSRMLS_DC)
+static void helper_free_storage(zend_object *obj)
 {
 	php_com_persist_helper *object = (php_com_persist_helper*)obj;
 
@@ -709,18 +709,18 @@ static void helper_free_storage(zend_object *obj TSRMLS_DC)
 	if (object->unk) {
 		IUnknown_Release(object->unk);
 	}
-	zend_object_std_dtor(&object->std TSRMLS_CC);
+	zend_object_std_dtor(&object->std);
 }
 
 
-static zend_object* helper_clone(zval *obj TSRMLS_DC)
+static zend_object* helper_clone(zval *obj)
 {
 	php_com_persist_helper *clone, *object = (php_com_persist_helper*)Z_OBJ_P(obj);
 
 	clone = emalloc(sizeof(*object));
 	memcpy(clone, object, sizeof(*object));
 
-	zend_object_std_init(&clone->std, object->std.ce TSRMLS_CC);
+	zend_object_std_init(&clone->std, object->std.ce);
 
 	if (clone->ipf) {
 		IPersistFile_AddRef(clone->ipf);
@@ -737,14 +737,14 @@ static zend_object* helper_clone(zval *obj TSRMLS_DC)
 	return (zend_object*)clone;
 }
 
-static zend_object* helper_new(zend_class_entry *ce TSRMLS_DC)
+static zend_object* helper_new(zend_class_entry *ce)
 {
 	php_com_persist_helper *helper;
 
 	helper = emalloc(sizeof(*helper));
 	memset(helper, 0, sizeof(*helper));
 
-	zend_object_std_init(&helper->std, helper_ce TSRMLS_CC);
+	zend_object_std_init(&helper->std, helper_ce);
 	helper->std.handlers = &helper_handlers;
 
 	return &helper->std;
@@ -760,7 +760,7 @@ int php_com_persist_minit(INIT_FUNC_ARGS)
 
 	INIT_CLASS_ENTRY(ce, "COMPersistHelper", com_persist_helper_methods);
 	ce.create_object = helper_new;
-	helper_ce = zend_register_internal_class(&ce TSRMLS_CC);
+	helper_ce = zend_register_internal_class(&ce);
 	helper_ce->ce_flags |= ZEND_ACC_FINAL;
 
 	le_istream = zend_register_list_destructors_ex(istream_dtor,
diff --git a/ext/com_dotnet/com_saproxy.c b/ext/com_dotnet/com_saproxy.c
index 1d187a77bf..481e95a2bd 100644
--- a/ext/com_dotnet/com_saproxy.c
+++ b/ext/com_dotnet/com_saproxy.c
@@ -71,21 +71,21 @@ static inline void clone_indices(php_com_saproxy *dest, php_com_saproxy *src, in
 	}
 }
 
-static zval *saproxy_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv TSRMLS_DC)
+static zval *saproxy_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv)
 {
 	ZVAL_NULL(rv);
 
-	php_com_throw_exception(E_INVALIDARG, "safearray has no properties" TSRMLS_CC);
+	php_com_throw_exception(E_INVALIDARG, "safearray has no properties");
 
 	return rv;
 }
 
-static void saproxy_property_write(zval *object, zval *member, zval *value, void **cache_slot TSRMLS_DC)
+static void saproxy_property_write(zval *object, zval *member, zval *value, void **cache_slot)
 {
-	php_com_throw_exception(E_INVALIDARG, "safearray has no properties" TSRMLS_CC);
+	php_com_throw_exception(E_INVALIDARG, "safearray has no properties");
 }
 
-static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *rv TSRMLS_DC)
+static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *rv)
 {
 	php_com_saproxy *proxy = SA_FETCH(object);
 	UINT dims, i;
@@ -114,20 +114,20 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
 
 		res = php_com_do_invoke(proxy->obj, Z_STRVAL(proxy->indices[0]),
 			   	Z_STRLEN(proxy->indices[0]), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v,
-			   	proxy->dimensions, args, 0 TSRMLS_CC);
+			   	proxy->dimensions, args, 0);
 
 		if (res == SUCCESS) {
-			php_com_zval_from_variant(rv, &v, proxy->obj->code_page TSRMLS_CC);
+			php_com_zval_from_variant(rv, &v, proxy->obj->code_page);
 			VariantClear(&v);
 		} else if (res == DISP_E_BADPARAMCOUNT) {
 			/* return another proxy */
-			php_com_saproxy_create(object, rv, offset TSRMLS_CC);
+			php_com_saproxy_create(object, rv, offset);
 		}
 
 		return rv;
 
 	} else if (!V_ISARRAY(&proxy->obj->v)) {
-		php_com_throw_exception(E_INVALIDARG, "invalid read from com proxy object" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "invalid read from com proxy object");
 		return rv;
 	}
 
@@ -141,7 +141,7 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
 
 	if ((UINT) proxy->dimensions >= dims) {
 		/* too many dimensions */
-		php_com_throw_exception(E_INVALIDARG, "too many dimensions!" TSRMLS_CC);
+		php_com_throw_exception(E_INVALIDARG, "too many dimensions!");
 		return rv;
 	}
 
@@ -150,7 +150,7 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
 	SafeArrayGetUBound(sa, proxy->dimensions, &ubound);
 
 	if (Z_LVAL_P(offset) < lbound || Z_LVAL_P(offset) > ubound) {
-		php_com_throw_exception(DISP_E_BADINDEX, "index out of bounds" TSRMLS_CC);
+		php_com_throw_exception(DISP_E_BADINDEX, "index out of bounds");
 		return rv;
 	}
 	
@@ -188,22 +188,22 @@ static zval *saproxy_read_dimension(zval *object, zval *offset, int type, zval *
 		efree(indices);
 
 		if (SUCCEEDED(res)) {
-			php_com_wrap_variant(rv, &v, proxy->obj->code_page TSRMLS_CC);
+			php_com_wrap_variant(rv, &v, proxy->obj->code_page);
 		} else {
-			php_com_throw_exception(res, NULL TSRMLS_CC);
+			php_com_throw_exception(res, NULL);
 		}
 
 		VariantClear(&v);
 		
 	} else {
 		/* return another proxy */
-		php_com_saproxy_create(object, rv, offset TSRMLS_CC);
+		php_com_saproxy_create(object, rv, offset);
 	}
 
 	return rv;
 }
 
-static void saproxy_write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC)
+static void saproxy_write_dimension(zval *object, zval *offset, zval *value)
 {
 	php_com_saproxy *proxy = SA_FETCH(object);
 	UINT dims, i;
@@ -226,7 +226,7 @@ static void saproxy_write_dimension(zval *object, zval *offset, zval *value TSRM
 		VariantInit(&v);
 		if (SUCCESS == php_com_do_invoke(proxy->obj, Z_STRVAL(proxy->indices[0]),
 					Z_STRLEN(proxy->indices[0]), DISPATCH_PROPERTYPUT, &v, proxy->dimensions + 1,
-					args, 0 TSRMLS_CC)) {
+					args, 0)) {
 			VariantClear(&v);
 		}
 
@@ -253,7 +253,7 @@ static void saproxy_write_dimension(zval *object, zval *offset, zval *value TSRM
 		}
 
 		VariantInit(&v);
-		php_com_variant_from_zval(&v, value, proxy->obj->code_page TSRMLS_CC);
+		php_com_variant_from_zval(&v, value, proxy->obj->code_page);
 
 		if (V_VT(&v) != vt) {
 			VariantChangeType(&v, &v, 0, vt);
@@ -269,54 +269,54 @@ static void saproxy_write_dimension(zval *object, zval *offset, zval *value TSRM
 		VariantClear(&v);
 
 		if (FAILED(res)) {
-			php_com_throw_exception(res, NULL TSRMLS_CC);
+			php_com_throw_exception(res, NULL);
 		}
 	} else {
-		php_com_throw_exception(E_NOTIMPL, "invalid write to com proxy object" TSRMLS_CC);
+		php_com_throw_exception(E_NOTIMPL, "invalid write to com proxy object");
 	}
 }
 
 #if 0
-static void saproxy_object_set(zval **property, zval *value TSRMLS_DC)
+static void saproxy_object_set(zval **property, zval *value)
 {
 }
 
-static zval *saproxy_object_get(zval *property TSRMLS_DC)
+static zval *saproxy_object_get(zval *property)
 {
 	/* Not yet implemented in the engine */
 	return NULL;
 }
 #endif
 
-static int saproxy_property_exists(zval *object, zval *member, int check_empty, void **cache_slot TSRMLS_DC)
+static int saproxy_property_exists(zval *object, zval *member, int check_empty, void **cache_slot)
 {
 	/* no properties */
 	return 0;
 }
 
-static int saproxy_dimension_exists(zval *object, zval *member, int check_empty TSRMLS_DC)
+static int saproxy_dimension_exists(zval *object, zval *member, int check_empty)
 {
-	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Operation not yet supported on a COM object");
+	php_error_docref(NULL, E_WARNING, "Operation not yet supported on a COM object");
 	return 0;
 }
 
-static void saproxy_property_delete(zval *object, zval *member, void **cache_slot TSRMLS_DC)
+static void saproxy_property_delete(zval *object, zval *member, void **cache_slot)
 {
-	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a COM object");
+	php_error_docref(NULL, E_WARNING, "Cannot delete properties from a COM object");
 }
 
-static void saproxy_dimension_delete(zval *object, zval *offset TSRMLS_DC)
+static void saproxy_dimension_delete(zval *object, zval *offset)
 {
-	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a COM object");
+	php_error_docref(NULL, E_WARNING, "Cannot delete properties from a COM object");
 }
 
-static HashTable *saproxy_properties_get(zval *object TSRMLS_DC)
+static HashTable *saproxy_properties_get(zval *object)
 {
 	/* no properties */
 	return NULL;
 }
 
-static union _zend_function *saproxy_method_get(zend_object **object, zend_string *name, const zval *key TSRMLS_DC)
+static union _zend_function *saproxy_method_get(zend_object **object, zend_string *name, const zval *key)
 {
 	/* no methods */
 	return NULL;
@@ -327,28 +327,28 @@ static int saproxy_call_method(zend_string *method, zend_object *object, INTERNA
 	return FAILURE;
 }
 
-static union _zend_function *saproxy_constructor_get(zend_object *object TSRMLS_DC)
+static union _zend_function *saproxy_constructor_get(zend_object *object)
 {
 	/* user cannot instantiate */
 	return NULL;
 }
 
-static zend_string* saproxy_class_name_get(const zend_object *object TSRMLS_DC)
+static zend_string* saproxy_class_name_get(const zend_object *object)
 {
 	return zend_string_copy(php_com_saproxy_class_entry->name);
 }
 
-static int saproxy_objects_compare(zval *object1, zval *object2 TSRMLS_DC)
+static int saproxy_objects_compare(zval *object1, zval *object2)
 {
 	return -1;
 }
 
-static int saproxy_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
+static int saproxy_object_cast(zval *readobj, zval *writeobj, int type)
 {
 	return FAILURE;
 }
 
-static int saproxy_count_elements(zval *object, zend_long *count TSRMLS_DC)
+static int saproxy_count_elements(zval *object, zend_long *count)
 {
 	php_com_saproxy *proxy = SA_FETCH(object);
 	LONG ubound, lbound;
@@ -365,7 +365,7 @@ static int saproxy_count_elements(zval *object, zend_long *count TSRMLS_DC)
 	return SUCCESS;
 }
 
-static void saproxy_free_storage(zend_object *object TSRMLS_DC)
+static void saproxy_free_storage(zend_object *object)
 {
 	php_com_saproxy *proxy = (php_com_saproxy *)object;
 //???	int i;
@@ -380,7 +380,7 @@ static void saproxy_free_storage(zend_object *object TSRMLS_DC)
 	efree(proxy->indices);
 }
 
-static zend_object* saproxy_clone(zval *object TSRMLS_DC)
+static zend_object* saproxy_clone(zval *object)
 {
 	php_com_saproxy *proxy = (php_com_saproxy *)Z_OBJ_P(object);
 	php_com_saproxy *cloneproxy;
@@ -421,7 +421,7 @@ zend_object_handlers php_com_saproxy_handlers = {
 	saproxy_count_elements
 };
 
-int php_com_saproxy_create(zval *com_object, zval *proxy_out, zval *index TSRMLS_DC)
+int php_com_saproxy_create(zval *com_object, zval *proxy_out, zval *index)
 {
 	php_com_saproxy *proxy, *rel = NULL;
 
@@ -447,7 +447,7 @@ int php_com_saproxy_create(zval *com_object, zval *proxy_out, zval *index TSRMLS
 
 	ZVAL_DUP(&proxy->indices[proxy->dimensions-1], index);
 
-	zend_object_std_init(&proxy->std, php_com_saproxy_class_entry TSRMLS_CC);
+	zend_object_std_init(&proxy->std, php_com_saproxy_class_entry);
 	proxy->std.handlers = &php_com_saproxy_handlers;
 	ZVAL_OBJ(proxy_out, &proxy->std);
 	
@@ -456,7 +456,7 @@ int php_com_saproxy_create(zval *com_object, zval *proxy_out, zval *index TSRMLS
 
 /* iterator */
 
-static void saproxy_iter_dtor(zend_object_iterator *iter TSRMLS_DC)
+static void saproxy_iter_dtor(zend_object_iterator *iter)
 {
 	php_com_saproxy_iter *I = (php_com_saproxy_iter*)Z_PTR(iter->data);
 
@@ -466,14 +466,14 @@ static void saproxy_iter_dtor(zend_object_iterator *iter TSRMLS_DC)
 	efree(I);
 }
 
-static int saproxy_iter_valid(zend_object_iterator *iter TSRMLS_DC)
+static int saproxy_iter_valid(zend_object_iterator *iter)
 {
 	php_com_saproxy_iter *I = (php_com_saproxy_iter*)Z_PTR(iter->data);
 
 	return (I->key < I->imax) ? SUCCESS : FAILURE;
 }
 
-static zval* saproxy_iter_get_data(zend_object_iterator *iter TSRMLS_DC)
+static zval* saproxy_iter_get_data(zend_object_iterator *iter)
 {
 	php_com_saproxy_iter *I = (php_com_saproxy_iter*)Z_PTR(iter->data);
 	VARIANT v;
@@ -497,13 +497,13 @@ static zval* saproxy_iter_get_data(zend_object_iterator *iter TSRMLS_DC)
 	}
 
 	ZVAL_NULL(&I->data);
-	php_com_wrap_variant(&I->data, &v, I->proxy->obj->code_page TSRMLS_CC);
+	php_com_wrap_variant(&I->data, &v, I->proxy->obj->code_page);
 	VariantClear(&v);
 
 	return &I->data;
 }
 
-static void saproxy_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
+static void saproxy_iter_get_key(zend_object_iterator *iter, zval *key)
 {
 	php_com_saproxy_iter *I = (php_com_saproxy_iter*)Z_PTR(iter->data);
 
@@ -514,7 +514,7 @@ static void saproxy_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC
 	}
 }
 
-static int saproxy_iter_move_forwards(zend_object_iterator *iter TSRMLS_DC)
+static int saproxy_iter_move_forwards(zend_object_iterator *iter)
 {
 	php_com_saproxy_iter *I = (php_com_saproxy_iter*)Z_PTR(iter->data);
 
@@ -535,7 +535,7 @@ static zend_object_iterator_funcs saproxy_iter_funcs = {
 };
 
 
-zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
+zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *object, int by_ref)
 {
 	php_com_saproxy *proxy = SA_FETCH(object);
 	php_com_saproxy_iter *I;
diff --git a/ext/com_dotnet/com_typeinfo.c b/ext/com_dotnet/com_typeinfo.c
index f07d7ff65d..2e2732afcd 100644
--- a/ext/com_dotnet/com_typeinfo.c
+++ b/ext/com_dotnet/com_typeinfo.c
@@ -35,7 +35,7 @@
  * b) a CLSID, major, minor e.g. "{00000200-0000-0010-8000-00AA006D2EA4},2,0"
  * c) a Type Library name e.g. "Microsoft OLE DB ActiveX Data Objects 1.0 Library"
  */
-PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codepage)
 {
 	ITypeLib *TL = NULL;
 	char *strtok_buf, *major, *minor;
@@ -52,7 +52,7 @@ PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codep
 	major = php_strtok_r(NULL, ",", &strtok_buf);
 	minor = php_strtok_r(NULL, ",", &strtok_buf);
 
-	p = php_com_string_to_olestring(search_string, strlen(search_string), codepage TSRMLS_CC);
+	p = php_com_string_to_olestring(search_string, strlen(search_string), codepage);
 
 	if (SUCCEEDED(CLSIDFromString(p, &clsid))) {
 		WORD major_i = 1, minor_i = 0;
@@ -129,7 +129,7 @@ PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codep
 										}
 										spprintf(&str, 0, "%s,%d,%d", keyname, major_tmp, minor_tmp);
 										/* recurse */
-										TL = php_com_load_typelib(str, codepage TSRMLS_CC);
+										TL = php_com_load_typelib(str, codepage);
 
 										efree(str);
 										break;
@@ -153,7 +153,7 @@ PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codep
 }
 
 /* Given a type-library, merge it into the current engine state */
-PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode, int codepage)
 {
 	int i, j, interfaces;
 	TYPEKIND pTKind;
@@ -185,7 +185,7 @@ PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode, int codepa
 					continue;
 				}
 
-				const_name = php_com_olestring_to_string(bstr_ids, &len, codepage TSRMLS_CC);
+				const_name = php_com_olestring_to_string(bstr_ids, &len, codepage);
 				c.name = zend_string_init(const_name, len, 1);
 				// TODO: avoid reallocation???
 				efree(const_name);
@@ -197,9 +197,9 @@ PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode, int codepa
 				SysFreeString(bstr_ids);
 
 				/* sanity check for the case where the constant is already defined */
-				if ((exists = zend_get_constant(c.name TSRMLS_CC)) != NULL) {
-					if (COMG(autoreg_verbose) && !compare_function(&results, &c.value, exists TSRMLS_CC)) {
-						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type library constant %s is already defined", c.name);
+				if ((exists = zend_get_constant(c.name)) != NULL) {
+					if (COMG(autoreg_verbose) && !compare_function(&results, &c.value, exists)) {
+						php_error_docref(NULL, E_WARNING, "Type library constant %s is already defined", c.name);
 					}
 					zend_string_release(c.name);
 					ITypeInfo_ReleaseVarDesc(TypeInfo, pVarDesc);
@@ -207,12 +207,12 @@ PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode, int codepa
 				}
 
 				/* register the constant */
-				php_com_zval_from_variant(&value, pVarDesc->lpvarValue, codepage TSRMLS_CC);
+				php_com_zval_from_variant(&value, pVarDesc->lpvarValue, codepage);
 				if (Z_TYPE(value) == IS_LONG) {
 					c.flags = mode;
 					ZVAL_LONG(&c.value, Z_LVAL(value));
 					c.module_number = 0;
-					zend_register_constant(&c TSRMLS_CC);
+					zend_register_constant(&c);
 				}
 				ITypeInfo_ReleaseVarDesc(TypeInfo, pVarDesc);
 			}
@@ -230,7 +230,7 @@ void php_com_typelibrary_dtor(void *pDest)
 }
 
 PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib_via_cache(char *search_string,
-	int codepage, int *cached TSRMLS_DC)
+	int codepage, int *cached)
 {
 	ITypeLib *TL;
 	char *name_dup;
@@ -247,7 +247,7 @@ PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib_via_cache(char *search_string,
 
 	*cached = 0;
 	name_dup = estrndup(search_string, l);
-	TL = php_com_load_typelib(name_dup, codepage TSRMLS_CC);
+	TL = php_com_load_typelib(name_dup, codepage);
 	efree(name_dup);
 
 	if (TL) {
@@ -261,7 +261,7 @@ PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib_via_cache(char *search_string,
 	return TL;
 }
 
-ITypeInfo *php_com_locate_typeinfo(char *typelibname, php_com_dotnet_object *obj, char *dispname, int sink TSRMLS_DC)
+ITypeInfo *php_com_locate_typeinfo(char *typelibname, php_com_dotnet_object *obj, char *dispname, int sink)
 {
 	ITypeInfo *typeinfo = NULL;
 	ITypeLib *typelib = NULL;
@@ -280,7 +280,7 @@ ITypeInfo *php_com_locate_typeinfo(char *typelibname, php_com_dotnet_object *obj
 			if (!gotguid && SUCCEEDED(IDispatch_QueryInterface(V_DISPATCH(&obj->v), &IID_IProvideClassInfo, (void**)&pci))) {
 				/* examine the available interfaces */
 				/* TODO: write some code here */
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "IProvideClassInfo: this code not yet written!");
+				php_error_docref(NULL, E_WARNING, "IProvideClassInfo: this code not yet written!");
 				IProvideClassInfo_Release(pci);
 			}
 		} else if (dispname == NULL) {
@@ -312,13 +312,13 @@ ITypeInfo *php_com_locate_typeinfo(char *typelibname, php_com_dotnet_object *obj
 		}
 	} else if (typelibname) {
 		/* Fetch the typelibrary and use that to look things up */
-		typelib = php_com_load_typelib(typelibname, CP_THREAD_ACP TSRMLS_CC);
+		typelib = php_com_load_typelib(typelibname, CP_THREAD_ACP);
 	} 
 
 	if (!gotguid && dispname && typelib) {
 		unsigned short cfound;
 		MEMBERID memid;
-		OLECHAR *olename = php_com_string_to_olestring(dispname, strlen(dispname), CP_ACP TSRMLS_CC);
+		OLECHAR *olename = php_com_string_to_olestring(dispname, strlen(dispname), CP_ACP);
 			
 		cfound = 1;
 		if (FAILED(ITypeLib_FindName(typelib, olename, 0, &typeinfo, &memid, &cfound)) || cfound == 0) {
@@ -417,20 +417,20 @@ static inline const char *vt_to_string(VARTYPE vt)
 	return "?";
 }
 
-static char *php_com_string_from_clsid(const CLSID *clsid, int codepage TSRMLS_DC)
+static char *php_com_string_from_clsid(const CLSID *clsid, int codepage)
 {
 	LPOLESTR ole_clsid;
 	char *clsid_str;
 
 	StringFromCLSID(clsid, &ole_clsid);
-	clsid_str = php_com_olestring_to_string(ole_clsid, NULL, codepage TSRMLS_CC);
+	clsid_str = php_com_olestring_to_string(ole_clsid, NULL, codepage);
 	LocalFree(ole_clsid);
 
 	return clsid_str;
 }
 
 
-int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int printdef, GUID *guid, int codepage TSRMLS_DC)
+int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int printdef, GUID *guid, int codepage)
 {
 	TYPEATTR *attr;
 	FUNCDESC *func;
@@ -455,10 +455,10 @@ int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int pri
 			char *guidstring;
 
 			ITypeInfo_GetDocumentation(typeinfo, MEMBERID_NIL, &olename, NULL, NULL, NULL);
-			ansiname = php_com_olestring_to_string(olename, &ansinamelen, codepage TSRMLS_CC);
+			ansiname = php_com_olestring_to_string(olename, &ansinamelen, codepage);
 			SysFreeString(olename);
 
-			guidstring = php_com_string_from_clsid(&attr->guid, codepage TSRMLS_CC);
+			guidstring = php_com_string_from_clsid(&attr->guid, codepage);
 			php_printf("class %s { /* GUID=%s */\n", ansiname, guidstring);
 			efree(guidstring);
 
@@ -485,7 +485,7 @@ int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int pri
 				lastid = func->memid;
 				
 				ITypeInfo_GetDocumentation(typeinfo, func->memid, &olename, NULL, NULL, NULL);
-				ansiname = php_com_olestring_to_string(olename, &ansinamelen, codepage TSRMLS_CC);
+				ansiname = php_com_olestring_to_string(olename, &ansinamelen, codepage);
 				SysFreeString(olename);
 
 				if (printdef) {
@@ -514,7 +514,7 @@ int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int pri
 
 						ITypeInfo_GetDocumentation(typeinfo, func->memid, NULL, &olename, NULL, NULL);
 						if (olename) {
-							funcdesc = php_com_olestring_to_string(olename, &funcdesclen, codepage TSRMLS_CC);
+							funcdesc = php_com_olestring_to_string(olename, &funcdesclen, codepage);
 							SysFreeString(olename);
 							php_printf("\t/* %s */\n", funcdesc);
 							efree(funcdesc);
@@ -547,7 +547,7 @@ int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int pri
 
 							/* when we handle prop put and get, this will look nicer */
 							if (j+1 < (int)cnames) {
-								funcdesc = php_com_olestring_to_string(names[j+1], &funcdesclen, codepage TSRMLS_CC);
+								funcdesc = php_com_olestring_to_string(names[j+1], &funcdesclen, codepage);
 								SysFreeString(names[j+1]);
 							} else {
 								funcdesc = "???";
@@ -568,7 +568,7 @@ int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int pri
 
 						ITypeInfo_GetDocumentation(typeinfo, func->memid, NULL, &olename, NULL, NULL);
 						if (olename) {
-							funcdesc = php_com_olestring_to_string(olename, &funcdesclen, codepage TSRMLS_CC);
+							funcdesc = php_com_olestring_to_string(olename, &funcdesclen, codepage);
 							SysFreeString(olename);
 							php_printf("\t\t/* %s */\n", funcdesc);
 							efree(funcdesc);
diff --git a/ext/com_dotnet/com_variant.c b/ext/com_dotnet/com_variant.c
index 7317b8d0e4..ce919d8a03 100644
--- a/ext/com_dotnet/com_variant.c
+++ b/ext/com_dotnet/com_variant.c
@@ -32,7 +32,7 @@
  * Only creates a single-dimensional array of variants.
  * The keys of the PHP hash MUST be numeric.  If the array
  * is sparse, then the gaps will be filled with NULL variants */
-static void safe_array_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
+static void safe_array_from_zval(VARIANT *v, zval *z, int codepage)
 {
 	SAFEARRAY *sa = NULL;
 	SAFEARRAYBOUND bound;
@@ -54,7 +54,7 @@ static void safe_array_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
 		} else if (HASH_KEY_NON_EXISTENT == keytype) {
 			break;
 		} else if (intindex > UINT_MAX) {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "COM: max number %u of elements in safe array exceeded", UINT_MAX);
+			php_error_docref(NULL, E_WARNING, "COM: max number %u of elements in safe array exceeded", UINT_MAX);
 			break;
 		}
 	}
@@ -75,7 +75,7 @@ static void safe_array_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
 			break;
 		}
 		zend_hash_get_current_key_ex(HASH_OF(z), &strindex, &intindex, 0, &pos);
-		php_com_variant_from_zval(&va[intindex], item, codepage TSRMLS_CC);		
+		php_com_variant_from_zval(&va[intindex], item, codepage);		
 	}
 
 	/* Unlock it and stuff it into our variant */
@@ -86,7 +86,7 @@ static void safe_array_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
 	return;
 
 bogus:
-	php_error_docref(NULL TSRMLS_CC, E_WARNING, "COM: converting from PHP array to VARIANT array; only arrays with numeric keys are allowed");
+	php_error_docref(NULL, E_WARNING, "COM: converting from PHP array to VARIANT array; only arrays with numeric keys are allowed");
 
 	V_VT(v) = VT_NULL;
 
@@ -96,7 +96,7 @@ bogus:
 	}
 }
 
-PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codepage)
 {
 	OLECHAR *olestring;
 	php_com_dotnet_object *obj;
@@ -118,7 +118,7 @@ PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codep
 			break;
 
 		case IS_OBJECT:
-			if (php_com_is_valid_object(z TSRMLS_CC)) {
+			if (php_com_is_valid_object(z)) {
 				obj = CDNO_FETCH(z);
 				if (V_VT(&obj->v) == VT_DISPATCH) {
 					/* pass the underlying object */
@@ -135,13 +135,13 @@ PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codep
 			} else {
 				/* export the PHP object using our COM wrapper */
 				V_VT(v) = VT_DISPATCH;
-				V_DISPATCH(v) = php_com_wrapper_export(z TSRMLS_CC);
+				V_DISPATCH(v) = php_com_wrapper_export(z);
 			}
 			break;
 			
 		case IS_ARRAY:
 			/* map as safe array */
-			safe_array_from_zval(v, z, codepage TSRMLS_CC);
+			safe_array_from_zval(v, z, codepage);
 			break;
 
 		case IS_LONG:
@@ -161,7 +161,7 @@ PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codep
 
 		case IS_STRING:
 			V_VT(v) = VT_BSTR;
-			olestring = php_com_string_to_olestring(Z_STRVAL_P(z), Z_STRLEN_P(z), codepage TSRMLS_CC);
+			olestring = php_com_string_to_olestring(Z_STRVAL_P(z), Z_STRLEN_P(z), codepage);
 			if (CP_UTF8 == codepage) {
 				V_BSTR(v) = SysAllocStringByteLen((char*)olestring, (UINT)(wcslen(olestring) * sizeof(OLECHAR)));
 			} else {
@@ -179,7 +179,7 @@ PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codep
 	}
 }
 
-PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage TSRMLS_DC)
+PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage)
 {
 	OLECHAR *olestring = NULL;
 	int ret = SUCCESS;
@@ -236,7 +236,7 @@ PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepa
 			if (olestring) {
 				size_t len;
 				char *str = php_com_olestring_to_string(olestring,
-					&len, codepage TSRMLS_CC);
+					&len, codepage);
 				ZVAL_STRINGL(z, str, len);
 				// TODO: avoid reallocation???
 				efree(str);
@@ -248,7 +248,7 @@ PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepa
 				IDispatch *disp;
 
 				if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
-					php_com_wrap_dispatch(z, disp, codepage TSRMLS_CC);
+					php_com_wrap_dispatch(z, disp, codepage);
 					IDispatch_Release(disp);
 				} else {
 					ret = FAILURE;
@@ -258,16 +258,16 @@ PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepa
 
 		case VT_DISPATCH:
 			if (V_DISPATCH(v) != NULL) {
-				php_com_wrap_dispatch(z, V_DISPATCH(v), codepage TSRMLS_CC);
+				php_com_wrap_dispatch(z, V_DISPATCH(v), codepage);
 			}
 			break;
 
 		case VT_VARIANT:
 			/* points to another variant */
-			return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage TSRMLS_CC);
+			return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage);
 			
 		default:
-			php_com_wrap_variant(z, v, codepage TSRMLS_CC);
+			php_com_wrap_variant(z, v, codepage);
 	}
 
 	if (olestring) {
@@ -275,14 +275,14 @@ PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepa
 	}
 
 	if (ret == FAILURE) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
+		php_error_docref(NULL, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
 	}
 
 	return ret;
 }
 
 
-PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar TSRMLS_DC)
+PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar)
 {
 	int ret = SUCCESS;
 	
@@ -422,10 +422,10 @@ PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar TSR
 		break;
 
 	case VT_VARIANT:
-		return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar TSRMLS_CC);
+		return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar);
 		
 	default:
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar));
+		php_error_docref(NULL, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar));
 		ret = FAILURE;
 	}
 	return ret;
@@ -448,19 +448,19 @@ PHP_FUNCTION(com_variant_create_instance)
 	
 	obj = CDNO_FETCH(object);
 	
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(),
 		"z!|ll", &zvalue, &vt, &codepage)) {
-			php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
+			php_com_throw_exception(E_INVALIDARG, "Invalid arguments");
 			return;
 	}
 
-	php_com_initialize(TSRMLS_C);
+	php_com_initialize();
 	if (ZEND_NUM_ARGS() == 3) {
 		obj->code_page = (int)codepage;
 	}
 
 	if (zvalue) {
-		php_com_variant_from_zval(&obj->v, zvalue, obj->code_page TSRMLS_CC);
+		php_com_variant_from_zval(&obj->v, zvalue, obj->code_page);
 	}
 
 	/* Only perform conversion if variant not already of type passed */
@@ -490,7 +490,7 @@ PHP_FUNCTION(com_variant_create_instance)
 				spprintf(&msg, 0, "Variant type conversion failed: %s", werr);
 				LocalFree(werr);
 
-				php_com_throw_exception(res, msg TSRMLS_CC);
+				php_com_throw_exception(res, msg);
 				efree(msg);
 			}
 		}
@@ -510,7 +510,7 @@ PHP_FUNCTION(variant_set)
 	zval *zobj, *zvalue = NULL;
 	php_com_dotnet_object *obj;
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(),
 			"Oz!", &zobj, php_com_variant_class_entry, &zvalue)) {
 		return;
 	}
@@ -523,14 +523,14 @@ PHP_FUNCTION(variant_set)
 		obj->typeinfo = NULL;
 	}
 	if (obj->sink_dispatch) {
-		php_com_object_enable_event_sink(obj, FALSE TSRMLS_CC);
+		php_com_object_enable_event_sink(obj, FALSE);
 		IDispatch_Release(obj->sink_dispatch);
 		obj->sink_dispatch = NULL;
 	}
 
 	VariantClear(&obj->v);
 
-	php_com_variant_from_zval(&obj->v, zvalue, obj->code_page TSRMLS_CC);
+	php_com_variant_from_zval(&obj->v, zvalue, obj->code_page);
 	/* remember we modified this variant */
 	obj->modified = 1;
 }
@@ -561,33 +561,33 @@ static void variant_binary_operation(enum variant_binary_opcode op, INTERNAL_FUN
 	VariantInit(&vres);
 
 	if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "OO", &zleft, php_com_variant_class_entry,
+			ZEND_NUM_ARGS(), "OO", &zleft, php_com_variant_class_entry,
 			&zright, php_com_variant_class_entry)) {
 		obj = CDNO_FETCH(zleft);
 		vleft = &obj->v;
 		obj = CDNO_FETCH(zright);
 		vright = &obj->v;
 	} else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "Oz!", &zleft, php_com_variant_class_entry,
+			ZEND_NUM_ARGS(), "Oz!", &zleft, php_com_variant_class_entry,
 			&zright)) {
 		obj = CDNO_FETCH(zleft);
 		vleft = &obj->v;
 		vright = &right_val;
-		php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vright, zright, codepage);
 	} else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "z!O", &zleft, &zright, php_com_variant_class_entry)) {
+			ZEND_NUM_ARGS(), "z!O", &zleft, &zright, php_com_variant_class_entry)) {
 		obj = CDNO_FETCH(zright);
 		vright = &obj->v;
 		vleft = &left_val;
-		php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
-	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+		php_com_variant_from_zval(vleft, zleft, codepage);
+	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(),
 			"z!z!", &zleft, &zright)) {
 
 		vleft = &left_val;
-		php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vleft, zleft, codepage);
 
 		vright = &right_val;
-		php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vright, zright, codepage);
 
 	} else {
 		return;
@@ -639,9 +639,9 @@ static void variant_binary_operation(enum variant_binary_opcode op, INTERNAL_FUN
 	}
 
 	if (SUCCEEDED(result)) {
-		php_com_wrap_variant(return_value, &vres, codepage TSRMLS_CC);
+		php_com_wrap_variant(return_value, &vres, codepage);
 	} else {
-		php_com_throw_exception(result, NULL TSRMLS_CC);
+		php_com_throw_exception(result, NULL);
 	}
 
 	VariantClear(&vres);
@@ -768,13 +768,13 @@ static void variant_unary_operation(enum variant_unary_opcode op, INTERNAL_FUNCT
 	VariantInit(&vres);
 
 	if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "O", &zleft, php_com_variant_class_entry)) {
+			ZEND_NUM_ARGS(), "O", &zleft, php_com_variant_class_entry)) {
 		obj = CDNO_FETCH(zleft);
 		vleft = &obj->v;
-	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(),
 			"z!", &zleft)) {
 		vleft = &left_val;
-		php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vleft, zleft, codepage);
 	} else {
 		return;
 	}
@@ -800,9 +800,9 @@ static void variant_unary_operation(enum variant_unary_opcode op, INTERNAL_FUNCT
 	}
 
 	if (SUCCEEDED(result)) {
-		php_com_wrap_variant(return_value, &vres, codepage TSRMLS_CC);
+		php_com_wrap_variant(return_value, &vres, codepage);
 	} else {
-		php_com_throw_exception(result, NULL TSRMLS_CC);
+		php_com_throw_exception(result, NULL);
 	}
 
 	VariantClear(&vres);
@@ -866,19 +866,19 @@ PHP_FUNCTION(variant_round)
 	VariantInit(&vres);
 
 	if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "Ol", &zleft, php_com_variant_class_entry, &decimals)) {
+			ZEND_NUM_ARGS(), "Ol", &zleft, php_com_variant_class_entry, &decimals)) {
 		obj = CDNO_FETCH(zleft);
 		vleft = &obj->v;
-	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(),
 			"z!l", &zleft, &decimals)) {
 		vleft = &left_val;
-		php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vleft, zleft, codepage);
 	} else {
 		return;
 	}
 
 	if (SUCCEEDED(VarRound(vleft, (int)decimals, &vres))) {
-		php_com_wrap_variant(return_value, &vres, codepage TSRMLS_CC);
+		php_com_wrap_variant(return_value, &vres, codepage);
 	}
 
 	VariantClear(&vres);
@@ -904,34 +904,34 @@ PHP_FUNCTION(variant_cmp)
 	VariantInit(&right_val);
 
 	if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "OO|ll", &zleft, php_com_variant_class_entry,
+			ZEND_NUM_ARGS(), "OO|ll", &zleft, php_com_variant_class_entry,
 			&zright, php_com_variant_class_entry, &lcid, &flags)) {
 		obj = CDNO_FETCH(zleft);
 		vleft = &obj->v;
 		obj = CDNO_FETCH(zright);
 		vright = &obj->v;
 	} else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "Oz!|ll", &zleft, php_com_variant_class_entry,
+			ZEND_NUM_ARGS(), "Oz!|ll", &zleft, php_com_variant_class_entry,
 			&zright, &lcid, &flags)) {
 		obj = CDNO_FETCH(zleft);
 		vleft = &obj->v;
 		vright = &right_val;
-		php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vright, zright, codepage);
 	} else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
-			ZEND_NUM_ARGS() TSRMLS_CC, "z!O|ll", &zleft, &zright, php_com_variant_class_entry,
+			ZEND_NUM_ARGS(), "z!O|ll", &zleft, &zright, php_com_variant_class_entry,
 			&lcid, &flags)) {
 		obj = CDNO_FETCH(zright);
 		vright = &obj->v;
 		vleft = &left_val;
-		php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
-	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+		php_com_variant_from_zval(vleft, zleft, codepage);
+	} else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(),
 			"z!z!|ll", &zleft, &zright, &lcid, &flags)) {
 
 		vleft = &left_val;
-		php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vleft, zleft, codepage);
 
 		vright = &right_val;
-		php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
+		php_com_variant_from_zval(vright, zright, codepage);
 
 	} else {
 		return;
@@ -954,7 +954,7 @@ PHP_FUNCTION(variant_date_to_timestamp)
 
 	VariantInit(&vres);
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(),
 		"O", &zleft, php_com_variant_class_entry)) {
 		return;
 	}
@@ -993,13 +993,13 @@ PHP_FUNCTION(variant_date_from_timestamp)
 	struct tm *tmv;
 	VARIANT res;
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "l",
 			&timestamp)) {
 		return;
 	}
 
 	if (timestamp < 0) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Timestamp value must be a positive value.");
+		php_error_docref(NULL, E_WARNING, "Timestamp value must be a positive value.");
 		RETURN_FALSE;
 	}
 
@@ -1019,7 +1019,7 @@ PHP_FUNCTION(variant_date_from_timestamp)
 	V_VT(&res) = VT_DATE;
 	SystemTimeToVariantTime(&systime, &V_DATE(&res));
 
-	php_com_wrap_variant(return_value, &res, CP_ACP TSRMLS_CC);
+	php_com_wrap_variant(return_value, &res, CP_ACP);
 
 	VariantClear(&res);
 }
@@ -1032,7 +1032,7 @@ PHP_FUNCTION(variant_get_type)
 	zval *zobj;
 	php_com_dotnet_object *obj;
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(),
 		"O", &zobj, php_com_variant_class_entry)) {
 		return;
 	}
@@ -1051,7 +1051,7 @@ PHP_FUNCTION(variant_set_type)
 	/* VARTYPE == unsigned short */ zend_long vt;
 	HRESULT res;
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(),
 		"Ol", &zobj, php_com_variant_class_entry, &vt)) {
 		return;
 	}
@@ -1071,7 +1071,7 @@ PHP_FUNCTION(variant_set_type)
 		spprintf(&msg, 0, "Variant type conversion failed: %s", werr);
 		LocalFree(werr);
 
-		php_com_throw_exception(res, msg TSRMLS_CC);
+		php_com_throw_exception(res, msg);
 		efree(msg);
 	}
 }
@@ -1087,7 +1087,7 @@ PHP_FUNCTION(variant_cast)
 	VARIANT vres;
 	HRESULT res;
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(),
 		"Ol", &zobj, php_com_variant_class_entry, &vt)) {
 		return;
 	}
@@ -1097,7 +1097,7 @@ PHP_FUNCTION(variant_cast)
 	res = VariantChangeType(&vres, &obj->v, 0, (VARTYPE)vt);
 
 	if (SUCCEEDED(res)) {
-		php_com_wrap_variant(return_value, &vres, obj->code_page TSRMLS_CC);
+		php_com_wrap_variant(return_value, &vres, obj->code_page);
 	} else {
 		char *werr, *msg;
 
@@ -1105,7 +1105,7 @@ PHP_FUNCTION(variant_cast)
 		spprintf(&msg, 0, "Variant type conversion failed: %s", werr);
 		LocalFree(werr);
 
-		php_com_throw_exception(res, msg TSRMLS_CC);
+		php_com_throw_exception(res, msg);
 		efree(msg);
 	}
 
diff --git a/ext/com_dotnet/com_wrapper.c b/ext/com_dotnet/com_wrapper.c
index f7dd7fd463..aa1c21c8f0 100644
--- a/ext/com_dotnet/com_wrapper.c
+++ b/ext/com_dotnet/com_wrapper.c
@@ -52,12 +52,12 @@ typedef struct {
 
 static int le_dispatch;
 
-static void disp_destructor(php_dispatchex *disp TSRMLS_DC);
+static void disp_destructor(php_dispatchex *disp);
 
-static void dispatch_dtor(zend_resource *rsrc TSRMLS_DC)
+static void dispatch_dtor(zend_resource *rsrc)
 {
 	php_dispatchex *disp = (php_dispatchex *)rsrc->ptr;
-	disp_destructor(disp TSRMLS_CC);
+	disp_destructor(disp);
 }
 
 int php_com_wrapper_minit(INIT_FUNC_ARGS)
@@ -179,7 +179,7 @@ static HRESULT STDMETHODCALLTYPE disp_getidsofnames(
 		size_t namelen;
 		zval *tmp;
 		
-		name = php_com_olestring_to_string(rgszNames[i], &namelen, COMG(code_page) TSRMLS_CC);
+		name = php_com_olestring_to_string(rgszNames[i], &namelen, COMG(code_page));
 		
 		/* Lookup the name in the hash */
 		if ((tmp = zend_hash_str_find(disp->name_to_dispid, name, namelen)) == NULL) {
@@ -224,7 +224,7 @@ static HRESULT STDMETHODCALLTYPE disp_getdispid(
 	zval *tmp;
 	FETCH_DISP("GetDispID");
 
-	name = php_com_olestring_to_string(bstrName, &namelen, COMG(code_page) TSRMLS_CC);
+	name = php_com_olestring_to_string(bstrName, &namelen, COMG(code_page));
 
 	trace("Looking for %s, namelen=%d in %p\n", name, namelen, disp->name_to_dispid);
 	
@@ -273,7 +273,7 @@ static HRESULT STDMETHODCALLTYPE disp_invokeex(
 
 				trace("alloc zval for arg %d VT=%08x\n", i, V_VT(arg));
 
-				php_com_wrap_variant(&params[i], arg, COMG(code_page) TSRMLS_CC);
+				php_com_wrap_variant(&params[i], arg, COMG(code_page));
 			}
 		}
 
@@ -283,14 +283,14 @@ static HRESULT STDMETHODCALLTYPE disp_invokeex(
 		 * and expose it as a COM exception */
 		
 		if (wFlags & DISPATCH_PROPERTYGET) {
-			retval = zend_read_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRLEN_P(name)+1, 1 TSRMLS_CC);
+			retval = zend_read_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRLEN_P(name)+1, 1);
 		} else if (wFlags & DISPATCH_PROPERTYPUT) {
-			zend_update_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRLEN_P(name), &params[0] TSRMLS_CC);
+			zend_update_property(Z_OBJCE(disp->object), &disp->object, Z_STRVAL_P(name), Z_STRLEN_P(name), &params[0]);
 		} else if (wFlags & DISPATCH_METHOD) {
 			zend_try {
 				retval = &rv;
 				if (SUCCESS == call_user_function_ex(EG(function_table), &disp->object, name,
-							retval, pdp->cArgs, params, 1, NULL TSRMLS_CC)) {
+							retval, pdp->cArgs, params, 1, NULL)) {
 					ret = S_OK;
 					trace("function called ok\n");
 
@@ -301,7 +301,7 @@ static HRESULT STDMETHODCALLTYPE disp_invokeex(
 						VARIANT *dstvar = &pdp->rgvarg[ pdp->cArgs - 1 - i];
 						if ((V_VT(dstvar) & VT_BYREF) && obj->modified ) {
 							trace("percolate modified value for arg %d VT=%08x\n", i, V_VT(dstvar));
-							php_com_copy_variant(dstvar, srcvar TSRMLS_CC);   
+							php_com_copy_variant(dstvar, srcvar);   
 						}
 					}
 				} else {
@@ -328,7 +328,7 @@ static HRESULT STDMETHODCALLTYPE disp_invokeex(
 		if (retval) {
 			if (pvarRes) {
 				VariantInit(pvarRes);
-				php_com_variant_from_zval(pvarRes, retval, COMG(code_page) TSRMLS_CC);
+				php_com_variant_from_zval(pvarRes, retval, COMG(code_page));
 			}
 			zval_ptr_dtor(retval);
 		} else if (pvarRes) {
@@ -385,7 +385,7 @@ static HRESULT STDMETHODCALLTYPE disp_getmembername(
 	FETCH_DISP("GetMemberName");
 
 	if (NULL != (name = zend_hash_index_find(disp->dispid_to_name, id))) {
-		OLECHAR *olestr = php_com_string_to_olestring(Z_STRVAL_P(name), Z_STRLEN_P(name), COMG(code_page) TSRMLS_CC);
+		OLECHAR *olestr = php_com_string_to_olestring(Z_STRVAL_P(name), Z_STRLEN_P(name), COMG(code_page));
 		*pbstrName = SysAllocString(olestr);
 		efree(olestr);
 		return S_OK;
@@ -444,7 +444,7 @@ static struct IDispatchExVtbl php_dispatch_vtbl = {
 
 /* enumerate functions and properties of the object and assign
  * dispatch ids */
-static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
+static void generate_dispids(php_dispatchex *disp)
 {
 	HashPosition pos;
 	zend_string *name = NULL;
@@ -529,7 +529,7 @@ static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
 	}
 }
 
-static php_dispatchex *disp_constructor(zval *object TSRMLS_DC)
+static php_dispatchex *disp_constructor(zval *object)
 {
 	php_dispatchex *disp = (php_dispatchex*)CoTaskMemAlloc(sizeof(php_dispatchex));
 	zval *tmp;
@@ -552,13 +552,13 @@ static php_dispatchex *disp_constructor(zval *object TSRMLS_DC)
 		ZVAL_UNDEF(&disp->object);
 	}
 
-	tmp = zend_list_insert(disp, le_dispatch TSRMLS_CC);
+	tmp = zend_list_insert(disp, le_dispatch);
 	disp->res = Z_RES_P(tmp);
 	
 	return disp;
 }
 
-static void disp_destructor(php_dispatchex *disp TSRMLS_DC)
+static void disp_destructor(php_dispatchex *disp)
 {	
 	/* Object store not available during request shutdown */
 	if (COMG(rshutdown_started)) {
@@ -583,9 +583,9 @@ static void disp_destructor(php_dispatchex *disp TSRMLS_DC)
 }
 
 PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *sinkid,
-	   HashTable *id_to_name TSRMLS_DC)
+	   HashTable *id_to_name)
 {
-	php_dispatchex *disp = disp_constructor(val TSRMLS_CC);
+	php_dispatchex *disp = disp_constructor(val);
 	HashPosition pos;
 	zend_string *name = NULL;
 	zval tmp, *ntmp;
@@ -618,7 +618,7 @@ PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *si
 	return (IDispatch*)disp;
 }
 
-PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val TSRMLS_DC)
+PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val)
 {
 	php_dispatchex *disp = NULL;
 
@@ -626,7 +626,7 @@ PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val TSRMLS_DC)
 		return NULL;
 	}
 
-	if (php_com_is_valid_object(val TSRMLS_CC)) {
+	if (php_com_is_valid_object(val)) {
 		/* pass back its IDispatch directly */
 		php_com_dotnet_object *obj = CDNO_FETCH(val);
 		
@@ -641,8 +641,8 @@ PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val TSRMLS_DC)
 		return NULL;
 	}
 
-	disp = disp_constructor(val TSRMLS_CC);
-	generate_dispids(disp TSRMLS_CC);
+	disp = disp_constructor(val);
+	generate_dispids(disp);
 
 	return (IDispatch*)disp;
 }
diff --git a/ext/com_dotnet/php_com_dotnet_internal.h b/ext/com_dotnet/php_com_dotnet_internal.h
index e06f50c7d6..518e27af1f 100644
--- a/ext/com_dotnet/php_com_dotnet_internal.h
+++ b/ext/com_dotnet/php_com_dotnet_internal.h
@@ -54,7 +54,7 @@ typedef struct _php_com_dotnet_object {
 	HashTable *id_of_name_cache;
 } php_com_dotnet_object;
 
-static inline int php_com_is_valid_object(zval *zv TSRMLS_DC)
+static inline int php_com_is_valid_object(zval *zv)
 {
 	zend_class_entry *ce = Z_OBJCE_P(zv);
 	return strcmp("com", ce->name->val) == 0 ||
@@ -64,8 +64,8 @@ static inline int php_com_is_valid_object(zval *zv TSRMLS_DC)
 
 #define CDNO_FETCH(zv)			(php_com_dotnet_object*)Z_OBJ_P(zv)
 #define CDNO_FETCH_VERIFY(obj, zv)	do { \
-	if (!php_com_is_valid_object(zv TSRMLS_CC)) { \
-		php_com_throw_exception(E_UNEXPECTED, "expected a variant object" TSRMLS_CC); \
+	if (!php_com_is_valid_object(zv)) { \
+		php_com_throw_exception(E_UNEXPECTED, "expected a variant object"); \
 		return; \
 	} \
 	obj = (php_com_dotnet_object*)Z_OBJ_P(zv); \
@@ -76,21 +76,21 @@ TsHashTable php_com_typelibraries;
 zend_class_entry *php_com_variant_class_entry, *php_com_exception_class_entry, *php_com_saproxy_class_entry;
 
 /* com_handlers.c */
-zend_object* php_com_object_new(zend_class_entry *ce TSRMLS_DC);
-zend_object* php_com_object_clone(zval *object TSRMLS_DC);
-void php_com_object_free_storage(zend_object *object TSRMLS_DC);
+zend_object* php_com_object_new(zend_class_entry *ce);
+zend_object* php_com_object_clone(zval *object);
+void php_com_object_free_storage(zend_object *object);
 zend_object_handlers php_com_object_handlers;
-void php_com_object_enable_event_sink(php_com_dotnet_object *obj, int enable TSRMLS_DC);
+void php_com_object_enable_event_sink(php_com_dotnet_object *obj, int enable);
 
 /* com_saproxy.c */
-zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
-int php_com_saproxy_create(zval *com_object, zval *proxy_out, zval *index TSRMLS_DC);
+zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *object, int by_ref);
+int php_com_saproxy_create(zval *com_object, zval *proxy_out, zval *index);
 
 /* com_olechar.c */
 PHP_COM_DOTNET_API char *php_com_olestring_to_string(OLECHAR *olestring,
-		size_t *string_len, int codepage TSRMLS_DC);
+		size_t *string_len, int codepage);
 PHP_COM_DOTNET_API OLECHAR *php_com_string_to_olestring(char *string,
-		size_t string_len, int codepage TSRMLS_DC);
+		size_t string_len, int codepage);
 
 
 /* com_com.c */
@@ -103,20 +103,20 @@ PHP_FUNCTION(com_load_typelib);
 PHP_FUNCTION(com_get_active_object);
 
 HRESULT php_com_invoke_helper(php_com_dotnet_object *obj, DISPID id_member,
-		WORD flags, DISPPARAMS *disp_params, VARIANT *v, int silent, int allow_noarg TSRMLS_DC);
+		WORD flags, DISPPARAMS *disp_params, VARIANT *v, int silent, int allow_noarg);
 HRESULT php_com_get_id_of_name(php_com_dotnet_object *obj, char *name,
-		size_t namelen, DISPID *dispid TSRMLS_DC);
+		size_t namelen, DISPID *dispid);
 int php_com_do_invoke_by_id(php_com_dotnet_object *obj, DISPID dispid,
-		WORD flags,	VARIANT *v, int nargs, zval *args, int silent, int allow_noarg TSRMLS_DC);
+		WORD flags,	VARIANT *v, int nargs, zval *args, int silent, int allow_noarg);
 int php_com_do_invoke(php_com_dotnet_object *obj, char *name, size_t namelen,
-		WORD flags,	VARIANT *v, int nargs, zval *args, int allow_noarg TSRMLS_DC);
+		WORD flags,	VARIANT *v, int nargs, zval *args, int allow_noarg);
 int php_com_do_invoke_byref(php_com_dotnet_object *obj, zend_internal_function *f,
-		WORD flags,	VARIANT *v, int nargs, zval *args TSRMLS_DC);
+		WORD flags,	VARIANT *v, int nargs, zval *args);
 
 /* com_wrapper.c */
 int php_com_wrapper_minit(INIT_FUNC_ARGS);
-PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *sinkid, HashTable *id_to_name TSRMLS_DC);
-PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val TSRMLS_DC);
+PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *sinkid, HashTable *id_to_name);
+PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val);
 
 /* com_persist.c */
 int php_com_persist_minit(INIT_FUNC_ARGS);
@@ -150,36 +150,36 @@ PHP_FUNCTION(variant_get_type);
 PHP_FUNCTION(variant_set_type);
 PHP_FUNCTION(variant_cast);
 
-PHP_COM_DOTNET_API void php_com_variant_from_zval_with_type(VARIANT *v, zval *z, VARTYPE type, int codepage TSRMLS_DC);
-PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC);
-PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage TSRMLS_DC);
-PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dst, VARIANT *src TSRMLS_DC);
+PHP_COM_DOTNET_API void php_com_variant_from_zval_with_type(VARIANT *v, zval *z, VARTYPE type, int codepage);
+PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codepage);
+PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage);
+PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dst, VARIANT *src);
 
 /* com_dotnet.c */
 PHP_FUNCTION(com_dotnet_create_instance);
-void php_com_dotnet_rshutdown(TSRMLS_D);
-void php_com_dotnet_mshutdown(TSRMLS_D);
+void php_com_dotnet_rshutdown(void);
+void php_com_dotnet_mshutdown(void);
 
 /* com_misc.c */
-void php_com_throw_exception(HRESULT code, char *message TSRMLS_DC);
+void php_com_throw_exception(HRESULT code, char *message);
 PHP_COM_DOTNET_API void php_com_wrap_dispatch(zval *z, IDispatch *disp,
-		int codepage TSRMLS_DC);
+		int codepage);
 PHP_COM_DOTNET_API void php_com_wrap_variant(zval *z, VARIANT *v,
-		int codepage TSRMLS_DC);
-PHP_COM_DOTNET_API int php_com_safearray_get_elem(VARIANT *array, VARIANT *dest, LONG dim1 TSRMLS_DC);
+		int codepage);
+PHP_COM_DOTNET_API int php_com_safearray_get_elem(VARIANT *array, VARIANT *dest, LONG dim1);
 
 /* com_typeinfo.c */
 PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib_via_cache(char *search_string,
-		int codepage, int *cached TSRMLS_DC);
-PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codepage TSRMLS_DC);
+		int codepage, int *cached);
+PHP_COM_DOTNET_API ITypeLib *php_com_load_typelib(char *search_string, int codepage);
 PHP_COM_DOTNET_API int php_com_import_typelib(ITypeLib *TL, int mode,
-		int codepage TSRMLS_DC);
+		int codepage);
 void php_com_typelibrary_dtor(void *pDest);
-ITypeInfo *php_com_locate_typeinfo(char *typelibname, php_com_dotnet_object *obj, char *dispname, int sink TSRMLS_DC);
-int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int printdef, GUID *guid, int codepage TSRMLS_DC);
+ITypeInfo *php_com_locate_typeinfo(char *typelibname, php_com_dotnet_object *obj, char *dispname, int sink);
+int php_com_process_typeinfo(ITypeInfo *typeinfo, HashTable *id_to_name, int printdef, GUID *guid, int codepage);
 
 /* com_iterator.c */
-zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
+zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref);
 
 
 #endif