diff --git a/ext/filter/logical_filters.c b/ext/filter/logical_filters.c
index e6fbaf86b370a..2dec236114182 100644
--- a/ext/filter/logical_filters.c
+++ b/ext/filter/logical_filters.c
@@ -612,14 +612,14 @@ zend_result php_filter_validate_url(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
 	int parser_name_set;
 	FETCH_STR_OPTION(parser_name, URL_OPTION_URI_PARSER_CLASS);
 
-	const uri_parser_t *uri_parser = php_uri_get_parser(parser_name_set ? parser_name : NULL);
+	const php_uri_parser *uri_parser = php_uri_get_parser(parser_name_set ? parser_name : NULL);
 	if (uri_parser == NULL) {
 		zend_value_error("%s(): \"uri_parser_class\" option has invalid value", get_active_function_name());
 		RETURN_VALIDATION_FAILED
 	}
 
 	/* Parse the URI - if it fails, we return NULL */
-	php_uri *uri = php_uri_parse_to_struct(uri_parser, Z_STRVAL_P(value), Z_STRLEN_P(value), URI_COMPONENT_READ_RAW, true);
+	php_uri *uri = php_uri_parse_to_struct(uri_parser, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_URI_COMPONENT_READ_MODE_RAW, true);
 	if (uri == NULL) {
 		RETURN_VALIDATION_FAILED
 	}
diff --git a/ext/openssl/xp_ssl.c b/ext/openssl/xp_ssl.c
index e76f99de6df6f..23f37355af568 100644
--- a/ext/openssl/xp_ssl.c
+++ b/ext/openssl/xp_ssl.c
@@ -2634,7 +2634,7 @@ static char *php_openssl_get_url_name(const char *resourcename,
 		return NULL;
 	}
 
-	const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("ssl", context);
+	const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("ssl", context);
 	if (uri_parser == NULL) {
 		zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
 		return NULL;
@@ -2647,7 +2647,7 @@ static char *php_openssl_get_url_name(const char *resourcename,
 
 	char * url_name = NULL;
 	zval host_zv;
-	zend_result result = php_uri_get_host(internal_uri, URI_COMPONENT_READ_RAW, &host_zv);
+	zend_result result = php_uri_get_host(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &host_zv);
 	if (result == SUCCESS && Z_TYPE(host_zv) == IS_STRING) {
 		const char * host = Z_STRVAL(host_zv);
 		size_t len = Z_STRLEN(host_zv);
diff --git a/ext/soap/php_http.c b/ext/soap/php_http.c
index 17754852004fe..ac5f0f0f9d1ed 100644
--- a/ext/soap/php_http.c
+++ b/ext/soap/php_http.c
@@ -431,12 +431,12 @@ int make_http_soap_request(
 	}
 
 	if (location != NULL && ZSTR_VAL(location)[0] != '\000') {
-		const uri_parser_t *uri_parser = php_uri_get_parser(uri_parser_class);
+		const php_uri_parser *uri_parser = php_uri_get_parser(uri_parser_class);
 		if (uri_parser == NULL) {
 			zend_argument_value_error(6, "must be a valid URI parser name");
 			return FALSE;
 		}
-		uri = php_uri_parse_to_struct(uri_parser, ZSTR_VAL(location), ZSTR_LEN(location), URI_COMPONENT_READ_RAW, true);
+		uri = php_uri_parse_to_struct(uri_parser, ZSTR_VAL(location), ZSTR_LEN(location), PHP_URI_COMPONENT_READ_MODE_RAW, true);
 	}
 
 	tmp = Z_CLIENT_STREAM_CONTEXT_P(this_ptr);
@@ -1148,14 +1148,14 @@ int make_http_soap_request(
 		char *loc;
 
 		if ((loc = get_http_header_value(ZSTR_VAL(http_headers), "Location:")) != NULL) {
-			const uri_parser_t *uri_parser = php_uri_get_parser(uri_parser_class);
+			const php_uri_parser *uri_parser = php_uri_get_parser(uri_parser_class);
 			if (uri_parser == NULL) {
 				efree(loc);
 				zend_argument_value_error(6, "must be a valid URI parser name");
 				return FALSE;
 			}
 
-			php_uri *new_uri = php_uri_parse_to_struct(uri_parser, loc, strlen(loc), URI_COMPONENT_READ_RAW, true);
+			php_uri *new_uri = php_uri_parse_to_struct(uri_parser, loc, strlen(loc), PHP_URI_COMPONENT_READ_MODE_RAW, true);
 			efree(loc);
 
 			if (new_uri != NULL) {
diff --git a/ext/standard/ftp_fopen_wrapper.c b/ext/standard/ftp_fopen_wrapper.c
index f4508b4657c10..c747020ad6290 100644
--- a/ext/standard/ftp_fopen_wrapper.c
+++ b/ext/standard/ftp_fopen_wrapper.c
@@ -135,13 +135,13 @@ static php_stream *php_ftp_fopen_connect(php_stream_wrapper *wrapper, const char
 	char *transport;
 	int transport_len;
 
-	const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("ftp", context);
+	const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("ftp", context);
 	if (uri_parser == NULL) {
 		zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
 		return NULL;
 	}
 
-	resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), URI_COMPONENT_READ_RAW, true);
+	resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), PHP_URI_COMPONENT_READ_MODE_RAW, true);
 	if (resource == NULL || resource->path == NULL) {
 		if (resource && presource) {
 			*presource = resource;
@@ -956,18 +956,18 @@ static int php_stream_ftp_rename(php_stream_wrapper *wrapper, const char *url_fr
 	int result;
 	char tmp_line[512];
 
-	const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("ftp", context);
+	const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("ftp", context);
 	if (uri_parser == NULL) {
 		zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
 		return 0;
 	}
 
-	resource_from = php_uri_parse_to_struct(uri_parser, url_from, strlen(url_from), URI_COMPONENT_READ_RAW, true);
+	resource_from = php_uri_parse_to_struct(uri_parser, url_from, strlen(url_from), PHP_URI_COMPONENT_READ_MODE_RAW, true);
 	if (!resource_from) {
 		return 0;
 	}
 
-	resource_to = php_uri_parse_to_struct(uri_parser, url_to, strlen(url_to), URI_COMPONENT_READ_RAW, true);
+	resource_to = php_uri_parse_to_struct(uri_parser, url_to, strlen(url_to), PHP_URI_COMPONENT_READ_MODE_RAW, true);
 	if (!resource_to) {
 		goto rename_errexit;
 	}
diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c
index 30057b70eea09..b8ede088517ca 100644
--- a/ext/standard/http_fopen_wrapper.c
+++ b/ext/standard/http_fopen_wrapper.c
@@ -393,12 +393,12 @@ static php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 		return NULL;
 	}
 
-	const uri_parser_t *uri_parser = php_stream_context_get_uri_parser("http", context);
+	const php_uri_parser *uri_parser = php_stream_context_get_uri_parser("http", context);
 	if (uri_parser == NULL) {
 		zend_value_error("%s(): Provided stream context has invalid value for the \"uri_parser_class\" option", get_active_function_name());
 		return NULL;
 	}
-	resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), URI_COMPONENT_READ_RAW, true);
+	resource = php_uri_parse_to_struct(uri_parser, path, strlen(path), PHP_URI_COMPONENT_READ_MODE_RAW, true);
 	if (resource == NULL) {
 		return NULL;
 	}
@@ -1097,7 +1097,7 @@ static php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 
 			php_uri_struct_free(resource);
 			/* check for invalid redirection URLs */
-			if ((resource = php_uri_parse_to_struct(uri_parser, new_path, strlen(new_path), URI_COMPONENT_READ_RAW, true)) == NULL) {
+			if ((resource = php_uri_parse_to_struct(uri_parser, new_path, strlen(new_path), PHP_URI_COMPONENT_READ_MODE_RAW, true)) == NULL) {
 				php_stream_wrapper_log_error(wrapper, options, "Invalid redirect URL! %s", new_path);
 				efree(new_path);
 				goto out;
diff --git a/ext/uri/php_uri.c b/ext/uri/php_uri.c
index 4ba1292582ee3..f3fc05bf1b485 100644
--- a/ext/uri/php_uri.c
+++ b/ext/uri/php_uri.c
@@ -62,45 +62,45 @@ static HashTable *uri_get_debug_properties(zend_object *object)
 		return result;
 	}
 
-	const uri_parser_t *parser = internal_uri->parser;
+	const php_uri_parser *parser = internal_uri->parser;
 
 	zval tmp;
-	if (parser->property_handlers.scheme.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.scheme.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_SCHEME), &tmp);
 	}
 
-	if (parser->property_handlers.username.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.username.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_USERNAME), &tmp);
 	}
 
-	if (parser->property_handlers.password.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.password.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_PASSWORD), &tmp);
 	}
 
-	if (parser->property_handlers.host.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.host.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_HOST), &tmp);
 	}
 
-	if (parser->property_handlers.port.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.port.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_PORT), &tmp);
 	}
 
-	if (parser->property_handlers.path.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.path.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_PATH), &tmp);
 	}
 
-	if (parser->property_handlers.query.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.query.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_QUERY), &tmp);
 	}
 
-	if (parser->property_handlers.fragment.read_func(internal_uri, URI_COMPONENT_READ_RAW, &tmp) == SUCCESS) {
+	if (parser->property_handler.fragment.read(internal_uri, PHP_URI_COMPONENT_READ_MODE_RAW, &tmp) == SUCCESS) {
 		zend_hash_update(result, ZSTR_KNOWN(ZEND_STR_FRAGMENT), &tmp);
 	}
 
 	return result;
 }
 
-PHPAPI const uri_parser_t *php_uri_get_parser(zend_string *uri_parser_name)
+PHPAPI const php_uri_parser *php_uri_get_parser(zend_string *uri_parser_name)
 {
 	if (uri_parser_name == NULL) {
 		return zend_hash_str_find_ptr(&uri_parsers, PHP_URI_PARSER_PHP_PARSE_URL, sizeof(PHP_URI_PARSER_PHP_PARSE_URL) - 1);
@@ -109,11 +109,11 @@ PHPAPI const uri_parser_t *php_uri_get_parser(zend_string *uri_parser_name)
 	return zend_hash_find_ptr(&uri_parsers, uri_parser_name);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, bool silent)
+ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, bool silent)
 {
 	uri_internal_t *internal_uri = emalloc(sizeof(*internal_uri));
 	internal_uri->parser = uri_parser;
-	internal_uri->uri = uri_parser->parse_uri(uri_str, uri_str_len, NULL, NULL, silent);
+	internal_uri->uri = uri_parser->parse(uri_str, uri_str_len, NULL, NULL, silent);
 
 	if (UNEXPECTED(internal_uri->uri == NULL)) {
 		efree(internal_uri);
@@ -123,66 +123,66 @@ ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const uri_parser_t *
 	return internal_uri;
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_get_property(const uri_internal_t *internal_uri, uri_property_name_t property_name, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_get_property(const uri_internal_t *internal_uri, php_uri_property_name property_name, php_uri_component_read_mode read_mode, zval *zv)
 {
-	const uri_property_handler_t *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
+	const php_uri_property_handler *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
 	if (property_handler == NULL) {
 		return FAILURE;
 	}
 
-	return property_handler->read_func(internal_uri, read_mode, zv);
+	return property_handler->read(internal_uri, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_SCHEME, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_SCHEME, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_username(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_username(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_USERNAME, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_USERNAME, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_password(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_password(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_PASSWORD, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_PASSWORD, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_host(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_host(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_HOST, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_HOST, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_port(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_port(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_PORT, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_PORT, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_path(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_path(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_PATH, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_PATH, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_query(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_query(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_QUERY, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_QUERY, read_mode, zv);
 }
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_fragment(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv)
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_fragment(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv)
 {
-	return php_uri_get_property(internal_uri, URI_PROPERTY_NAME_FRAGMENT, read_mode, zv);
+	return php_uri_get_property(internal_uri, PHP_URI_PROPERTY_NAME_FRAGMENT, read_mode, zv);
 }
 
 ZEND_ATTRIBUTE_NONNULL PHPAPI void php_uri_free(uri_internal_t *internal_uri)
 {
-	internal_uri->parser->free_uri(internal_uri->uri);
+	internal_uri->parser->free(internal_uri->uri);
 	internal_uri->uri = NULL;
 	internal_uri->parser = NULL;
 	efree(internal_uri);
 }
 
 ZEND_ATTRIBUTE_NONNULL PHPAPI php_uri *php_uri_parse_to_struct(
-	const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, uri_component_read_mode_t read_mode, bool silent
+	const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, php_uri_component_read_mode read_mode, bool silent
 ) {
 	uri_internal_t *uri_internal = php_uri_parse(uri_parser, uri_str, uri_str_len, silent);
 	if (uri_internal == NULL) {
@@ -341,7 +341,7 @@ ZEND_ATTRIBUTE_NONNULL_ARGS(1, 2) PHPAPI void php_uri_instantiate_uri(
 		uri_object = Z_URI_OBJECT_P(return_value);
 	}
 
-	const uri_parser_t *uri_parser = uri_object->internal.parser;
+	const php_uri_parser *uri_parser = uri_object->internal.parser;
 
 	zval errors;
 	ZVAL_UNDEF(&errors);
@@ -355,7 +355,7 @@ ZEND_ATTRIBUTE_NONNULL_ARGS(1, 2) PHPAPI void php_uri_instantiate_uri(
 		base_url = internal_base_url->uri;
 	}
 
-	void *uri = uri_parser->parse_uri(ZSTR_VAL(uri_str), ZSTR_LEN(uri_str), base_url, errors_zv != NULL ? &errors : NULL, !should_throw);
+	void *uri = uri_parser->parse(ZSTR_VAL(uri_str), ZSTR_LEN(uri_str), base_url, errors_zv != NULL ? &errors : NULL, !should_throw);
 	if (UNEXPECTED(uri == NULL)) {
 		if (should_throw) {
 			zval_ptr_dtor(&errors);
@@ -370,7 +370,7 @@ ZEND_ATTRIBUTE_NONNULL_ARGS(1, 2) PHPAPI void php_uri_instantiate_uri(
 	}
 
 	if (pass_errors_by_ref_and_free(errors_zv, &errors) == FAILURE) {
-		uri_parser->free_uri(uri);
+		uri_parser->free(uri);
 		RETURN_THROWS();
 	}
 
@@ -516,20 +516,20 @@ PHP_METHOD(Uri_WhatWg_Url, __construct)
 
 PHP_METHOD(Uri_Rfc3986_Uri, getScheme)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawScheme)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, withScheme)
 {
-	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME);
+	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME);
 }
 
-static void rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAMETERS, uri_component_read_mode_t read_mode)
+static void rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAMETERS, php_uri_component_read_mode read_mode)
 {
 	ZEND_PARSE_PARAMETERS_NONE();
 
@@ -544,12 +544,12 @@ static void rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAMETERS, uri_component_re
 
 PHP_METHOD(Uri_Rfc3986_Uri, getUserInfo)
 {
-	rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawUserInfo)
 {
-	rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_COMPONENT_READ_RAW);
+	rfc3986_userinfo_read(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, withUserInfo)
@@ -590,92 +590,92 @@ PHP_METHOD(Uri_Rfc3986_Uri, withUserInfo)
 
 PHP_METHOD(Uri_Rfc3986_Uri, getUsername)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_USERNAME, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_USERNAME, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawUsername)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_USERNAME, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_USERNAME, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getPassword)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PASSWORD, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PASSWORD, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawPassword)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PASSWORD, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PASSWORD, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getHost)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawHost)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, withHost)
 {
-	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST);
+	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getPort)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PORT, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PORT, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, withPort)
 {
-	uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PORT);
+	uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PORT);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getPath)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PATH, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PATH, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawPath)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PATH, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PATH, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, withPath)
 {
-	uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PATH);
+	uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PATH);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getQuery)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_QUERY, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_QUERY, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawQuery)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_QUERY, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_QUERY, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, withQuery)
 {
-	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_QUERY);
+	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_QUERY);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getFragment)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, getRawFragment)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT, URI_COMPONENT_READ_RAW);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT, PHP_URI_COMPONENT_READ_MODE_RAW);
 }
 
 PHP_METHOD(Uri_Rfc3986_Uri, withFragment)
 {
-	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT);
+	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT);
 }
 
 static void throw_cannot_recompose_uri_to_string(zend_object *object)
@@ -705,15 +705,15 @@ static void uri_equals(INTERNAL_FUNCTION_PARAMETERS, zend_object *that_object, z
 		exclude_fragment = zend_string_equals_literal(Z_STR_P(case_name), "ExcludeFragment");
 	}
 
-	zend_string *this_str = this_internal_uri->parser->uri_to_string(
-		this_internal_uri->uri, URI_RECOMPOSITION_NORMALIZED_ASCII, exclude_fragment);
+	zend_string *this_str = this_internal_uri->parser->to_string(
+		this_internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII, exclude_fragment);
 	if (this_str == NULL) {
 		throw_cannot_recompose_uri_to_string(this_object);
 		RETURN_THROWS();
 	}
 
-	zend_string *that_str = that_internal_uri->parser->uri_to_string(
-		that_internal_uri->uri, URI_RECOMPOSITION_NORMALIZED_ASCII, exclude_fragment);
+	zend_string *that_str = that_internal_uri->parser->to_string(
+		that_internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII, exclude_fragment);
 	if (that_str == NULL) {
 		zend_string_release(this_str);
 		throw_cannot_recompose_uri_to_string(that_object);
@@ -748,7 +748,7 @@ PHP_METHOD(Uri_Rfc3986_Uri, toRawString)
 	uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
 	URI_ASSERT_INITIALIZATION(internal_uri);
 
-	zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false);
+	zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false);
 	if (uri_str == NULL) {
 		throw_cannot_recompose_uri_to_string(this_object);
 		RETURN_THROWS();
@@ -765,7 +765,7 @@ PHP_METHOD(Uri_Rfc3986_Uri, toString)
 	uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
 	URI_ASSERT_INITIALIZATION(internal_uri);
 
-	zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_NORMALIZED_ASCII, false);
+	zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII, false);
 	if (uri_str == NULL) {
 		throw_cannot_recompose_uri_to_string(this_object);
 		RETURN_THROWS();
@@ -794,7 +794,7 @@ PHP_METHOD(Uri_Rfc3986_Uri, __serialize)
 	URI_ASSERT_INITIALIZATION(internal_uri);
 
 	/* Serialize state: "uri" key in the first array */
-	zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false);
+	zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false);
 	if (uri_str == NULL) {
 		throw_cannot_recompose_uri_to_string(this_object);
 		RETURN_THROWS();
@@ -851,8 +851,8 @@ static void uri_unserialize(INTERNAL_FUNCTION_PARAMETERS)
 	}
 
 	uri_internal_t *internal_uri = uri_internal_from_obj(object);
-	internal_uri->parser->free_uri(internal_uri->uri);
-	internal_uri->uri = internal_uri->parser->parse_uri(Z_STRVAL_P(uri_zv), Z_STRLEN_P(uri_zv), NULL, NULL, true);
+	internal_uri->parser->free(internal_uri->uri);
+	internal_uri->uri = internal_uri->parser->parse(Z_STRVAL_P(uri_zv), Z_STRLEN_P(uri_zv), NULL, NULL, true);
 	if (internal_uri->uri == NULL) {
 		zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(object->ce->name));
 		RETURN_THROWS();
@@ -888,37 +888,37 @@ PHP_METHOD(Uri_Rfc3986_Uri, __debugInfo)
 
 PHP_METHOD(Uri_WhatWg_Url, getScheme)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_WhatWg_Url, withScheme)
 {
-	uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_SCHEME);
+	uri_write_component_str(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_SCHEME);
 }
 
 PHP_METHOD(Uri_WhatWg_Url, withUsername)
 {
-	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_USERNAME);
+	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_USERNAME);
 }
 
 PHP_METHOD(Uri_WhatWg_Url, withPassword)
 {
-	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_PASSWORD);
+	uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_PASSWORD);
 }
 
 PHP_METHOD(Uri_WhatWg_Url, getAsciiHost)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_NORMALIZED_ASCII);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII);
 }
 
 PHP_METHOD(Uri_WhatWg_Url, getUnicodeHost)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_HOST, URI_COMPONENT_READ_NORMALIZED_UNICODE);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_HOST, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE);
 }
 
 PHP_METHOD(Uri_WhatWg_Url, getFragment)
 {
-	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, URI_PROPERTY_NAME_FRAGMENT, URI_COMPONENT_READ_NORMALIZED_UNICODE);
+	uri_read_component(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_URI_PROPERTY_NAME_FRAGMENT, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE);
 }
 
 PHP_METHOD(Uri_WhatWg_Url, equals)
@@ -943,7 +943,7 @@ PHP_METHOD(Uri_WhatWg_Url, toUnicodeString)
 	uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
 	URI_ASSERT_INITIALIZATION(internal_uri);
 
-	RETURN_STR(internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_UNICODE, false));
+	RETURN_STR(internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE, false));
 }
 
 PHP_METHOD(Uri_WhatWg_Url, toAsciiString)
@@ -954,7 +954,7 @@ PHP_METHOD(Uri_WhatWg_Url, toAsciiString)
 	uri_internal_t *internal_uri = uri_internal_from_obj(this_object);
 	URI_ASSERT_INITIALIZATION(internal_uri);
 
-	RETURN_STR(internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false));
+	RETURN_STR(internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false));
 }
 
 PHP_METHOD(Uri_WhatWg_Url, resolve)
@@ -980,7 +980,7 @@ PHP_METHOD(Uri_WhatWg_Url, __serialize)
 	URI_ASSERT_INITIALIZATION(internal_uri);
 
 	/* Serialize state: "uri" key in the first array */
-	zend_string *uri_str = internal_uri->parser->uri_to_string(internal_uri->uri, URI_RECOMPOSITION_RAW_ASCII, false);
+	zend_string *uri_str = internal_uri->parser->to_string(internal_uri->uri, PHP_URI_RECOMPOSITION_MODE_RAW_ASCII, false);
 	if (uri_str == NULL) {
 		throw_cannot_recompose_uri_to_string(this_object);
 		RETURN_THROWS();
@@ -1015,7 +1015,7 @@ PHP_METHOD(Uri_WhatWg_Url, __debugInfo)
 	RETURN_ARR(uri_get_debug_properties(object));
 }
 
-PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const uri_parser_t *parser)
+PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const php_uri_parser *parser)
 {
 	uri_object_t *uri_object = zend_object_alloc(sizeof(*uri_object), class_type);
 
@@ -1044,7 +1044,7 @@ PHPAPI void php_uri_object_handler_free(zend_object *object)
 {
 	uri_object_t *uri_object = uri_object_from_obj(object);
 
-	uri_object->internal.parser->free_uri(uri_object->internal.uri);
+	uri_object->internal.parser->free(uri_object->internal.uri);
 	zend_object_std_dtor(&uri_object->std);
 }
 
@@ -1058,7 +1058,7 @@ PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object)
 	uri_object_t *new_uri_object = uri_object_from_obj(object->ce->create_object(object->ce));
 	ZEND_ASSERT(new_uri_object->internal.parser == internal_uri->parser);
 
-	void *uri = internal_uri->parser->clone_uri(internal_uri->uri);
+	void *uri = internal_uri->parser->clone(internal_uri->uri);
 	ZEND_ASSERT(uri != NULL);
 
 	new_uri_object->internal.uri = uri;
@@ -1068,15 +1068,15 @@ PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object)
 	return &new_uri_object->std;
 }
 
-PHPAPI zend_result php_uri_parser_register(const uri_parser_t *uri_parser)
+PHPAPI zend_result php_uri_parser_register(const php_uri_parser *uri_parser)
 {
 	zend_string *key = zend_string_init_interned(uri_parser->name, strlen(uri_parser->name), true);
 
 	ZEND_ASSERT(uri_parser->name != NULL);
-	ZEND_ASSERT(uri_parser->parse_uri != NULL);
-	ZEND_ASSERT(uri_parser->clone_uri != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
-	ZEND_ASSERT(uri_parser->uri_to_string != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
-	ZEND_ASSERT(uri_parser->free_uri != NULL);
+	ZEND_ASSERT(uri_parser->parse != NULL);
+	ZEND_ASSERT(uri_parser->clone != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
+	ZEND_ASSERT(uri_parser->to_string != NULL || strcmp(uri_parser->name, PHP_URI_PARSER_PHP_PARSE_URL) == 0);
+	ZEND_ASSERT(uri_parser->free != NULL);
 
 	zend_result result = zend_hash_add_ptr(&uri_parsers, key, (void *) uri_parser) != NULL ? SUCCESS : FAILURE;
 
diff --git a/ext/uri/php_uri.h b/ext/uri/php_uri.h
index 3d0b703dafc0d..97125f2b2700f 100644
--- a/ext/uri/php_uri.h
+++ b/ext/uri/php_uri.h
@@ -39,7 +39,7 @@ typedef struct php_uri {
  * @param uri_parser The URI parser
  * @return SUCCESS in case of success, FAILURE otherwise
  */
-PHPAPI zend_result php_uri_parser_register(const uri_parser_t *uri_parser);
+PHPAPI zend_result php_uri_parser_register(const php_uri_parser *uri_parser);
 
 /**
  * Returns the registered URI parser based on uri_parser_name.
@@ -47,129 +47,129 @@ PHPAPI zend_result php_uri_parser_register(const uri_parser_t *uri_parser);
  * @param uri_parser_name The URI parser name
  * @return The URI parser
  */
-PHPAPI const uri_parser_t *php_uri_get_parser(zend_string *uri_parser_name);
+PHPAPI const php_uri_parser *php_uri_get_parser(zend_string *uri_parser_name);
 
-ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, bool silent);
+ZEND_ATTRIBUTE_NONNULL PHPAPI uri_internal_t *php_uri_parse(const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, bool silent);
 
 /**
  * Retrieves the scheme component based on the read_mode and passes it to the zv ZVAL in case of success.
  * 
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_scheme(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Retrieves the username component based on the read_mode and passes it to the zv ZVAL in case of success.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_username(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_username(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Retrieves the password component based on the read_mode and passes it to the zv ZVAL in case of success.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_password(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_password(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Retrieves the host component based on the read_mode and passes it to the zv ZVAL in case of success.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_host(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_host(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Retrieves the port component based on the read_mode and passes it to the zv ZVAL in case of success.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_LONG or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_port(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_port(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Retrieves the path component based on the read_mode and passes it to the zv ZVAL in case of success.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_path(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_path(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Retrieves the query component based on the read_mode and passes it to the zv ZVAL in case of success.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_query(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_query(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Retrieves the fragment component based on the read_mode and passes it to the zv ZVAL in case of success.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
  * @param internal_uri The internal URI whose uri member is used to retrieve the component
  * @param read_mode The read mode
  * @param zv The output parameter containing the retrieved component as a ZVAL (either IS_STRING or IS_NULL).
  * @return SUCCESS in case of success, FAILURE otherwise.
  */
-ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_fragment(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *zv);
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_uri_get_fragment(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *zv);
 
 /**
  * Frees the uri member within the provided internal URI.
@@ -182,11 +182,11 @@ ZEND_ATTRIBUTE_NONNULL PHPAPI void php_uri_free(uri_internal_t *internal_uri);
  * Creates a new php_uri struct containing all the URI components. The components are retrieved based on the read_mode parameter.
  *
  * Read_mode can be one of the following:
- * - URI_COMPONENT_READ_RAW: Retrieves the raw, non-normalized variant of the URI component
- * - URI_COMPONENT_READ_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
- * - URI_COMPONENT_READ_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
+ * - PHP_URI_COMPONENT_READ_MODE_RAW: Retrieves the raw, non-normalized variant of the URI component
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII: Retrieves the normalized variant of the requested URI component that must only contain ASCII characters
+ * - PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: Retrieves the normalized variant of the requested URI component that may contain Unicode codepoints
  *
- * @param uri_parser The URI parser whose parse_uri() handler is called
+ * @param uri_parser The URI parser whose parse() handler is called
  * @param uri_str The input string that is going to be parsed
  * @param uri_str_len Length of the input string
  * @param read_mode The read mode based on which components are retrieved
@@ -194,7 +194,7 @@ ZEND_ATTRIBUTE_NONNULL PHPAPI void php_uri_free(uri_internal_t *internal_uri);
  * @return The created php_uri struct in case of success, NULL otherwise
  */
 ZEND_ATTRIBUTE_NONNULL PHPAPI php_uri *php_uri_parse_to_struct(
-		const uri_parser_t *uri_parser, const char *uri_str, size_t uri_str_len, uri_component_read_mode_t read_mode, bool silent
+		const php_uri_parser *uri_parser, const char *uri_str, size_t uri_str_len, php_uri_component_read_mode read_mode, bool silent
 );
 
 /**
diff --git a/ext/uri/php_uri_common.c b/ext/uri/php_uri_common.c
index 6bb3f7d9946cc..7bee8f46f6e02 100644
--- a/ext/uri/php_uri_common.c
+++ b/ext/uri/php_uri_common.c
@@ -19,69 +19,69 @@
 #include "Zend/zend_exceptions.h"
 #include "php_uri_common.h"
 
-const uri_property_handler_t *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, uri_property_name_t property_name)
+const php_uri_property_handler *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, php_uri_property_name property_name)
 {
 	switch (property_name) {
-		case URI_PROPERTY_NAME_SCHEME:
-			return &internal_uri->parser->property_handlers.scheme;
-		case URI_PROPERTY_NAME_USERNAME:
-			return &internal_uri->parser->property_handlers.username;
-		case URI_PROPERTY_NAME_PASSWORD:
-			return &internal_uri->parser->property_handlers.password;
-		case URI_PROPERTY_NAME_HOST:
-			return &internal_uri->parser->property_handlers.host;
-		case URI_PROPERTY_NAME_PORT:
-			return &internal_uri->parser->property_handlers.port;
-		case URI_PROPERTY_NAME_PATH:
-			return &internal_uri->parser->property_handlers.path;
-		case URI_PROPERTY_NAME_QUERY:
-			return &internal_uri->parser->property_handlers.query;
-		case URI_PROPERTY_NAME_FRAGMENT:
-			return &internal_uri->parser->property_handlers.fragment;
+		case PHP_URI_PROPERTY_NAME_SCHEME:
+			return &internal_uri->parser->property_handler.scheme;
+		case PHP_URI_PROPERTY_NAME_USERNAME:
+			return &internal_uri->parser->property_handler.username;
+		case PHP_URI_PROPERTY_NAME_PASSWORD:
+			return &internal_uri->parser->property_handler.password;
+		case PHP_URI_PROPERTY_NAME_HOST:
+			return &internal_uri->parser->property_handler.host;
+		case PHP_URI_PROPERTY_NAME_PORT:
+			return &internal_uri->parser->property_handler.port;
+		case PHP_URI_PROPERTY_NAME_PATH:
+			return &internal_uri->parser->property_handler.path;
+		case PHP_URI_PROPERTY_NAME_QUERY:
+			return &internal_uri->parser->property_handler.query;
+		case PHP_URI_PROPERTY_NAME_FRAGMENT:
+			return &internal_uri->parser->property_handler.fragment;
 		EMPTY_SWITCH_DEFAULT_CASE()
 	}
 }
 
-static zend_string *get_known_string_by_property_name(uri_property_name_t property_name)
+static zend_string *get_known_string_by_property_name(php_uri_property_name property_name)
 {
 	switch (property_name) {
-		case URI_PROPERTY_NAME_SCHEME:
+		case PHP_URI_PROPERTY_NAME_SCHEME:
 			return ZSTR_KNOWN(ZEND_STR_SCHEME);
-		case URI_PROPERTY_NAME_USERNAME:
+		case PHP_URI_PROPERTY_NAME_USERNAME:
 			return ZSTR_KNOWN(ZEND_STR_USERNAME);
-		case URI_PROPERTY_NAME_PASSWORD:
+		case PHP_URI_PROPERTY_NAME_PASSWORD:
 			return ZSTR_KNOWN(ZEND_STR_PASSWORD);
-		case URI_PROPERTY_NAME_HOST:
+		case PHP_URI_PROPERTY_NAME_HOST:
 			return ZSTR_KNOWN(ZEND_STR_HOST);
-		case URI_PROPERTY_NAME_PORT:
+		case PHP_URI_PROPERTY_NAME_PORT:
 			return ZSTR_KNOWN(ZEND_STR_PORT);
-		case URI_PROPERTY_NAME_PATH:
+		case PHP_URI_PROPERTY_NAME_PATH:
 			return ZSTR_KNOWN(ZEND_STR_PATH);
-		case URI_PROPERTY_NAME_QUERY:
+		case PHP_URI_PROPERTY_NAME_QUERY:
 			return ZSTR_KNOWN(ZEND_STR_QUERY);
-		case URI_PROPERTY_NAME_FRAGMENT:
+		case PHP_URI_PROPERTY_NAME_FRAGMENT:
 			return ZSTR_KNOWN(ZEND_STR_FRAGMENT);
 		EMPTY_SWITCH_DEFAULT_CASE()
 	}
 }
 
-void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name, uri_component_read_mode_t component_read_mode)
+void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name, php_uri_component_read_mode component_read_mode)
 {
 	ZEND_PARSE_PARAMETERS_NONE();
 
 	uri_internal_t *internal_uri = Z_URI_INTERNAL_P(ZEND_THIS);
 	URI_ASSERT_INITIALIZATION(internal_uri);
 
-	const uri_property_handler_t *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
+	const php_uri_property_handler *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
 	ZEND_ASSERT(property_handler != NULL);
 
-	if (UNEXPECTED(property_handler->read_func(internal_uri, component_read_mode, return_value) == FAILURE)) {
+	if (UNEXPECTED(property_handler->read(internal_uri, component_read_mode, return_value) == FAILURE)) {
 		zend_throw_error(NULL, "The %s component cannot be retrieved", ZSTR_VAL(get_known_string_by_property_name(property_name)));
 		RETURN_THROWS();
 	}
 }
 
-static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name, zval *property_zv)
+static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name, zval *property_zv)
 {
 	zend_object *old_object = Z_OBJ_P(ZEND_THIS);
 	uri_internal_t *internal_uri = Z_URI_INTERNAL_P(ZEND_THIS);
@@ -96,12 +96,12 @@ static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_na
 	 * case of an exception being thrown. */
 	RETVAL_OBJ(new_object);
 
-	const uri_property_handler_t *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
+	const php_uri_property_handler *property_handler = uri_property_handler_from_internal_uri(internal_uri, property_name);
 	ZEND_ASSERT(property_handler != NULL);
 
 	uri_internal_t *new_internal_uri = uri_internal_from_obj(new_object);
 	URI_ASSERT_INITIALIZATION(new_internal_uri);
-	if (UNEXPECTED(property_handler->write_func == NULL)) {
+	if (UNEXPECTED(property_handler->write == NULL)) {
 		zend_readonly_property_modification_error_ex(ZSTR_VAL(old_object->ce->name),
 			ZSTR_VAL(get_known_string_by_property_name(property_name)));
 		RETURN_THROWS();
@@ -109,7 +109,7 @@ static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_na
 
 	zval errors;
 	ZVAL_UNDEF(&errors);
-	if (UNEXPECTED(property_handler->write_func(new_internal_uri, property_zv, &errors) == FAILURE)) {
+	if (UNEXPECTED(property_handler->write(new_internal_uri, property_zv, &errors) == FAILURE)) {
 		zval_ptr_dtor(&errors);
 		RETURN_THROWS();
 	}
@@ -117,7 +117,7 @@ static void uri_write_component_ex(INTERNAL_FUNCTION_PARAMETERS, uri_property_na
 	ZEND_ASSERT(Z_ISUNDEF(errors));
 }
 
-void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name)
+void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name)
 {
 	zend_string *value;
 
@@ -131,7 +131,7 @@ void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t p
 	uri_write_component_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, property_name, &zv);
 }
 
-void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name)
+void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name)
 {
 	zend_string *value;
 
@@ -149,7 +149,7 @@ void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_
 	uri_write_component_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, property_name, &zv);
 }
 
-void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name)
+void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name)
 {
 	zend_long value;
 	bool value_is_null;
diff --git a/ext/uri/php_uri_common.h b/ext/uri/php_uri_common.h
index 1db692136e1a5..a49d7f5b2445f 100644
--- a/ext/uri/php_uri_common.h
+++ b/ext/uri/php_uri_common.h
@@ -28,42 +28,42 @@ extern zend_class_entry *uri_whatwg_invalid_url_exception_ce;
 extern zend_class_entry *uri_whatwg_url_validation_error_type_ce;
 extern zend_class_entry *uri_whatwg_url_validation_error_ce;
 
-typedef enum {
-	URI_RECOMPOSITION_RAW_ASCII,
-	URI_RECOMPOSITION_RAW_UNICODE,
-	URI_RECOMPOSITION_NORMALIZED_ASCII,
-	URI_RECOMPOSITION_NORMALIZED_UNICODE,
-} uri_recomposition_mode_t;
-
-typedef enum {
-	URI_COMPONENT_READ_RAW,
-	URI_COMPONENT_READ_NORMALIZED_ASCII,
-	URI_COMPONENT_READ_NORMALIZED_UNICODE,
-} uri_component_read_mode_t;
+typedef enum php_uri_recomposition_mode {
+	PHP_URI_RECOMPOSITION_MODE_RAW_ASCII,
+	PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE,
+	PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII,
+	PHP_URI_RECOMPOSITION_MODE_NORMALIZED_UNICODE,
+} php_uri_recomposition_mode;
+
+typedef enum php_uri_component_read_mode {
+	PHP_URI_COMPONENT_READ_MODE_RAW,
+	PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII,
+	PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE,
+} php_uri_component_read_mode;
 
 struct uri_internal_t;
 
-typedef zend_result (*uri_read_t)(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval);
+typedef zend_result (*php_uri_property_handler_read)(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval);
 
-typedef zend_result (*uri_write_t)(struct uri_internal_t *internal_uri, zval *value, zval *errors);
+typedef zend_result (*php_uri_property_handler_write)(struct uri_internal_t *internal_uri, zval *value, zval *errors);
 
-typedef enum {
-	URI_PROPERTY_NAME_SCHEME,
-	URI_PROPERTY_NAME_USERNAME,
-	URI_PROPERTY_NAME_PASSWORD,
-	URI_PROPERTY_NAME_HOST,
-	URI_PROPERTY_NAME_PORT,
-	URI_PROPERTY_NAME_PATH,
-	URI_PROPERTY_NAME_QUERY,
-	URI_PROPERTY_NAME_FRAGMENT,
-} uri_property_name_t;
+typedef enum php_uri_property_name {
+	PHP_URI_PROPERTY_NAME_SCHEME,
+	PHP_URI_PROPERTY_NAME_USERNAME,
+	PHP_URI_PROPERTY_NAME_PASSWORD,
+	PHP_URI_PROPERTY_NAME_HOST,
+	PHP_URI_PROPERTY_NAME_PORT,
+	PHP_URI_PROPERTY_NAME_PATH,
+	PHP_URI_PROPERTY_NAME_QUERY,
+	PHP_URI_PROPERTY_NAME_FRAGMENT,
+} php_uri_property_name;
 
-typedef struct uri_property_handler_t {
-	uri_read_t read_func;
-	uri_write_t write_func;
-} uri_property_handler_t;
+typedef struct php_uri_property_handler {
+	php_uri_property_handler_read read;
+	php_uri_property_handler_write write;
+} php_uri_property_handler;
 
-typedef struct uri_parser_t {
+typedef struct php_uri_parser {
 	/**
 	 * Name (the FQCN) of the URI parser. The "" name is reserved for the handler of the legacy parse_url().
 	 */
@@ -91,7 +91,7 @@ typedef struct uri_parser_t {
 	 * @param errors An out parameter that stores additional error information
 	 * @param silent Whether to throw a Uri\InvalidUriException in case of failure
 	 */
-	void *(*parse_uri)(const char *uri_str, size_t uri_str_len, const void *base_url, zval *errors, bool silent);
+	void *(*parse)(const char *uri_str, size_t uri_str_len, const void *base_url, zval *errors, bool silent);
 
 	/**
 	 * Clones a URI to a new URI.
@@ -100,46 +100,46 @@ typedef struct uri_parser_t {
 	 * @param uri The input URI
 	 * @return The cloned URI
 	 */
-	void *(*clone_uri)(void *uri);
+	void *(*clone)(void *uri);
 
 	/**
 	 * Recomposes a URI as a string according to the recomposition_mode and exclude_fragment parameters.
 	 * The returned zend_string must not be persistent.
 	 *
 	 * Recomposition_mode can be one of the following:
-	 * - URI_RECOMPOSITION_RAW_ASCII: Recomposes the raw, non-normalized variant of the URI as a string that must only contain ASCII characters
-	 * - URI_RECOMPOSITION_RAW_UNICODE: Recomposes the raw, non-normalized variant of the URI as a string that may contain Unicode codepoints
-	 * - URI_RECOMPOSITION_NORMALIZED_ASCII: Recomposes the normalized variant of the URI as a string that must only contain ASCII characters
-	 * - URI_RECOMPOSITION_NORMALIZED_UNICODE: Recomposes the normalized variant of the URI as a string that may contain Unicode codepoints
+	 * - PHP_URI_RECOMPOSITION_MODE_RAW_ASCII: Recomposes the raw, non-normalized variant of the URI as a string that must only contain ASCII characters
+	 * - PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE: Recomposes the raw, non-normalized variant of the URI as a string that may contain Unicode codepoints
+	 * - PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII: Recomposes the normalized variant of the URI as a string that must only contain ASCII characters
+	 * - PHP_URI_RECOMPOSITION_MODE_NORMALIZED_UNICODE: Recomposes the normalized variant of the URI as a string that may contain Unicode codepoints
 	 *
 	 * @param uri The input URI
 	 * @param recomposition_mode The type of recomposition
 	 * @param exclude_fragment Whether the fragment component should be part of the recomposed URI
 	 * @return The recomposed URI as a non-persistent zend_string
 	 */
-	zend_string *(*uri_to_string)(void *uri, uri_recomposition_mode_t recomposition_mode, bool exclude_fragment);
+	zend_string *(*to_string)(void *uri, php_uri_recomposition_mode recomposition_mode, bool exclude_fragment);
 
 	/**
 	 * Frees the provided URI.
 	 *
 	 * @param uri The URI to free. Must do nothing if NULL.
 	 */
-	void (*free_uri)(void *uri);
+	void (*free)(void *uri);
 
 	struct {
-		uri_property_handler_t scheme;
-		uri_property_handler_t username;
-		uri_property_handler_t password;
-		uri_property_handler_t host;
-		uri_property_handler_t port;
-		uri_property_handler_t path;
-		uri_property_handler_t query;
-		uri_property_handler_t fragment;
-	} property_handlers;
-} uri_parser_t;
+		php_uri_property_handler scheme;
+		php_uri_property_handler username;
+		php_uri_property_handler password;
+		php_uri_property_handler host;
+		php_uri_property_handler port;
+		php_uri_property_handler path;
+		php_uri_property_handler query;
+		php_uri_property_handler fragment;
+	} property_handler;
+} php_uri_parser;
 
 typedef struct uri_internal_t {
-	const uri_parser_t *parser;
+	const php_uri_parser *parser;
 	void *uri;
 } uri_internal_t;
 
@@ -159,7 +159,7 @@ static inline uri_internal_t *uri_internal_from_obj(const zend_object *object) {
 #define Z_URI_OBJECT_P(zv) uri_object_from_obj(Z_OBJ_P((zv)))
 #define Z_URI_INTERNAL_P(zv) uri_internal_from_obj(Z_OBJ_P((zv)))
 
-PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const uri_parser_t *parser);
+PHPAPI uri_object_t *php_uri_object_create(zend_class_entry *class_type, const php_uri_parser *parser);
 PHPAPI void php_uri_object_handler_free(zend_object *object);
 PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object);
 
@@ -168,11 +168,11 @@ PHPAPI zend_object *php_uri_object_handler_clone(zend_object *object);
 #define PHP_URI_PARSER_PHP_PARSE_URL "parse_url"
 #define URI_SERIALIZED_PROPERTY_NAME "uri"
 
-const uri_property_handler_t *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, uri_property_name_t property_name);
-void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name, uri_component_read_mode_t component_read_mode);
-void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name);
-void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name);
-void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, uri_property_name_t property_name);
+const php_uri_property_handler *uri_property_handler_from_internal_uri(const uri_internal_t *internal_uri, php_uri_property_name property_name);
+void uri_read_component(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name, php_uri_component_read_mode component_read_mode);
+void uri_write_component_str(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name);
+void uri_write_component_str_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name);
+void uri_write_component_long_or_null(INTERNAL_FUNCTION_PARAMETERS, php_uri_property_name property_name);
 
 #define URI_ASSERT_INITIALIZATION(internal_uri) do { \
 	ZEND_ASSERT(internal_uri != NULL && internal_uri->uri != NULL); \
diff --git a/ext/uri/uri_parser_php_parse_url.c b/ext/uri/uri_parser_php_parse_url.c
index 1803bdb56fca7..45649dcc92a7a 100644
--- a/ext/uri/uri_parser_php_parse_url.c
+++ b/ext/uri/uri_parser_php_parse_url.c
@@ -21,13 +21,13 @@
 #include "Zend/zend_exceptions.h"
 #include "ext/standard/url.h"
 
-static zend_string *decode_component(zend_string *in, uri_component_read_mode_t read_mode)
+static zend_string *decode_component(zend_string *in, php_uri_component_read_mode read_mode)
 {
 	switch (read_mode) {
-	case URI_COMPONENT_READ_RAW:
+	case PHP_URI_COMPONENT_READ_MODE_RAW:
 		return zend_string_copy(in);
-	case URI_COMPONENT_READ_NORMALIZED_ASCII:
-	case URI_COMPONENT_READ_NORMALIZED_UNICODE: {
+	case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII:
+	case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: {
 		zend_string *out = zend_string_alloc(ZSTR_LEN(in), false);
 
 		ZSTR_LEN(out) = php_raw_url_decode_ex(ZSTR_VAL(out), ZSTR_VAL(in), ZSTR_LEN(in));
@@ -38,7 +38,7 @@ static zend_string *decode_component(zend_string *in, uri_component_read_mode_t
 	}
 }
 
-static zend_result uri_parser_php_parse_url_scheme_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_scheme_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -51,7 +51,7 @@ static zend_result uri_parser_php_parse_url_scheme_read(const uri_internal_t *in
 	return SUCCESS;
 }
 
-static zend_result uri_parser_php_parse_url_username_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_username_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -64,7 +64,7 @@ static zend_result uri_parser_php_parse_url_username_read(const uri_internal_t *
 	return SUCCESS;
 }
 
-static zend_result uri_parser_php_parse_url_password_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_password_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -77,7 +77,7 @@ static zend_result uri_parser_php_parse_url_password_read(const uri_internal_t *
 	return SUCCESS;
 }
 
-static zend_result uri_parser_php_parse_url_host_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_host_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -90,7 +90,7 @@ static zend_result uri_parser_php_parse_url_host_read(const uri_internal_t *inte
 	return SUCCESS;
 }
 
-static zend_result uri_parser_php_parse_url_port_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_port_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -103,7 +103,7 @@ static zend_result uri_parser_php_parse_url_port_read(const uri_internal_t *inte
 	return SUCCESS;
 }
 
-static zend_result uri_parser_php_parse_url_path_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_path_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -116,7 +116,7 @@ static zend_result uri_parser_php_parse_url_path_read(const uri_internal_t *inte
 	return SUCCESS;
 }
 
-static zend_result uri_parser_php_parse_url_query_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_query_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -129,7 +129,7 @@ static zend_result uri_parser_php_parse_url_query_read(const uri_internal_t *int
 	return SUCCESS;
 }
 
-static zend_result uri_parser_php_parse_url_fragment_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result uri_parser_php_parse_url_fragment_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const php_url *parse_url_uri = internal_uri->uri;
 
@@ -165,20 +165,20 @@ static void uri_parser_php_parse_url_free(void *uri)
 	php_url_free(parse_url_uri);
 }
 
-const uri_parser_t php_uri_parser_php_parse_url = {
+const php_uri_parser php_uri_parser_php_parse_url = {
 	.name = PHP_URI_PARSER_PHP_PARSE_URL,
-	.parse_uri = uri_parser_php_parse_url_parse,
-	.clone_uri = NULL,
-	.uri_to_string = NULL,
-	.free_uri = uri_parser_php_parse_url_free,
+	.parse = uri_parser_php_parse_url_parse,
+	.clone = NULL,
+	.to_string = NULL,
+	.free = uri_parser_php_parse_url_free,
 	{
-		.scheme = {.read_func = uri_parser_php_parse_url_scheme_read, .write_func = NULL},
-		.username = {.read_func = uri_parser_php_parse_url_username_read, .write_func = NULL},
-		.password = {.read_func = uri_parser_php_parse_url_password_read, .write_func = NULL},
-		.host = {.read_func = uri_parser_php_parse_url_host_read, .write_func = NULL},
-		.port = {.read_func = uri_parser_php_parse_url_port_read, .write_func = NULL},
-		.path = {.read_func = uri_parser_php_parse_url_path_read, .write_func = NULL},
-		.query = {.read_func = uri_parser_php_parse_url_query_read, .write_func = NULL},
-		.fragment = {.read_func = uri_parser_php_parse_url_fragment_read, .write_func = NULL},
+		.scheme = {.read = uri_parser_php_parse_url_scheme_read, .write = NULL},
+		.username = {.read = uri_parser_php_parse_url_username_read, .write = NULL},
+		.password = {.read = uri_parser_php_parse_url_password_read, .write = NULL},
+		.host = {.read = uri_parser_php_parse_url_host_read, .write = NULL},
+		.port = {.read = uri_parser_php_parse_url_port_read, .write = NULL},
+		.path = {.read = uri_parser_php_parse_url_path_read, .write = NULL},
+		.query = {.read = uri_parser_php_parse_url_query_read, .write = NULL},
+		.fragment = {.read = uri_parser_php_parse_url_fragment_read, .write = NULL},
 	}
 };
diff --git a/ext/uri/uri_parser_php_parse_url.h b/ext/uri/uri_parser_php_parse_url.h
index ef98088a26c45..ae2d862faf403 100644
--- a/ext/uri/uri_parser_php_parse_url.h
+++ b/ext/uri/uri_parser_php_parse_url.h
@@ -20,6 +20,6 @@
 
 #include "php_uri_common.h"
 
-extern const uri_parser_t php_uri_parser_php_parse_url;
+extern const php_uri_parser php_uri_parser_php_parse_url;
 
 #endif
diff --git a/ext/uri/uri_parser_rfc3986.c b/ext/uri/uri_parser_rfc3986.c
index f2e4d1e72b6ab..7cb2637cb47f6 100644
--- a/ext/uri/uri_parser_rfc3986.c
+++ b/ext/uri/uri_parser_rfc3986.c
@@ -86,14 +86,14 @@ ZEND_ATTRIBUTE_NONNULL static UriUriA *get_normalized_uri(php_uri_parser_rfc3986
 	return &uriparser_uris->normalized_uri;
 }
 
-ZEND_ATTRIBUTE_NONNULL static UriUriA *get_uri_for_reading(php_uri_parser_rfc3986_uris *uriparser_uris, uri_component_read_mode_t read_mode)
+ZEND_ATTRIBUTE_NONNULL static UriUriA *get_uri_for_reading(php_uri_parser_rfc3986_uris *uriparser_uris, php_uri_component_read_mode read_mode)
 {
 	switch (read_mode) {
-		case URI_COMPONENT_READ_RAW:
+		case PHP_URI_COMPONENT_READ_MODE_RAW:
 			return &uriparser_uris->uri;
-		case URI_COMPONENT_READ_NORMALIZED_ASCII:
+		case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII:
 			ZEND_FALLTHROUGH;
-		case URI_COMPONENT_READ_NORMALIZED_UNICODE:
+		case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE:
 			return get_normalized_uri(uriparser_uris);
 		EMPTY_SWITCH_DEFAULT_CASE()
 	}
@@ -106,7 +106,7 @@ ZEND_ATTRIBUTE_NONNULL static UriUriA *get_uri_for_writing(uri_internal_t *inter
 	return &uriparser_uris->uri;
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_scheme_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_scheme_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -143,7 +143,7 @@ static zend_result php_uri_parser_rfc3986_scheme_write(struct uri_internal_t *in
 	}
 }
 
-ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -183,7 +183,7 @@ zend_result php_uri_parser_rfc3986_userinfo_write(struct uri_internal_t *interna
 	}
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_username_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_username_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -205,7 +205,7 @@ ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_username_read(c
 	return SUCCESS;
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_password_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_password_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -224,7 +224,7 @@ ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_password_read(c
 	return SUCCESS;
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_host_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_host_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -296,7 +296,7 @@ ZEND_ATTRIBUTE_NONNULL static zend_long port_str_to_zend_long_checked(const char
 	return (zend_long)result;
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_port_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_port_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -338,7 +338,7 @@ static zend_result php_uri_parser_rfc3986_port_write(struct uri_internal_t *inte
 	}
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_path_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_path_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -390,7 +390,7 @@ static zend_result php_uri_parser_rfc3986_path_write(struct uri_internal_t *inte
 	}
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_query_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_query_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -427,7 +427,7 @@ static zend_result php_uri_parser_rfc3986_query_write(struct uri_internal_t *int
 	}
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_fragment_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+ZEND_ATTRIBUTE_NONNULL static zend_result php_uri_parser_rfc3986_fragment_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const UriUriA *uriparser_uri = get_uri_for_reading(internal_uri->uri, read_mode);
 
@@ -564,12 +564,12 @@ ZEND_ATTRIBUTE_NONNULL static void *php_uri_parser_rfc3986_clone(void *uri)
 	return new_uriparser_uris;
 }
 
-ZEND_ATTRIBUTE_NONNULL static zend_string *php_uri_parser_rfc3986_to_string(void *uri, uri_recomposition_mode_t recomposition_mode, bool exclude_fragment)
+ZEND_ATTRIBUTE_NONNULL static zend_string *php_uri_parser_rfc3986_to_string(void *uri, php_uri_recomposition_mode recomposition_mode, bool exclude_fragment)
 {
 	php_uri_parser_rfc3986_uris *uriparser_uris = uri;
 	const UriUriA *uriparser_uri;
 
-	if (recomposition_mode == URI_RECOMPOSITION_RAW_ASCII || recomposition_mode == URI_RECOMPOSITION_RAW_UNICODE) {
+	if (recomposition_mode == PHP_URI_RECOMPOSITION_MODE_RAW_ASCII || recomposition_mode == PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE) {
 		uriparser_uri = &uriparser_uris->uri;
 	} else {
 		uriparser_uri = get_normalized_uri(uriparser_uris);
@@ -609,20 +609,20 @@ static void php_uri_parser_rfc3986_free(void *uri)
 	efree(uriparser_uris);
 }
 
-const uri_parser_t php_uri_parser_rfc3986 = {
+const php_uri_parser php_uri_parser_rfc3986 = {
 	.name = PHP_URI_PARSER_RFC3986,
-	.parse_uri = php_uri_parser_rfc3986_parse,
-	.clone_uri = php_uri_parser_rfc3986_clone,
-	.uri_to_string = php_uri_parser_rfc3986_to_string,
-	.free_uri = php_uri_parser_rfc3986_free,
+	.parse = php_uri_parser_rfc3986_parse,
+	.clone = php_uri_parser_rfc3986_clone,
+	.to_string = php_uri_parser_rfc3986_to_string,
+	.free = php_uri_parser_rfc3986_free,
 	{
-		.scheme = {.read_func = php_uri_parser_rfc3986_scheme_read, .write_func = php_uri_parser_rfc3986_scheme_write},
-		.username = {.read_func = php_uri_parser_rfc3986_username_read, .write_func = NULL},
-		.password = {.read_func = php_uri_parser_rfc3986_password_read, .write_func = NULL},
-		.host = {.read_func = php_uri_parser_rfc3986_host_read, .write_func = php_uri_parser_rfc3986_host_write},
-		.port = {.read_func = php_uri_parser_rfc3986_port_read, .write_func = php_uri_parser_rfc3986_port_write},
-		.path = {.read_func = php_uri_parser_rfc3986_path_read, .write_func = php_uri_parser_rfc3986_path_write},
-		.query = {.read_func = php_uri_parser_rfc3986_query_read, .write_func = php_uri_parser_rfc3986_query_write},
-		.fragment = {.read_func = php_uri_parser_rfc3986_fragment_read, .write_func = php_uri_parser_rfc3986_fragment_write},
+		.scheme = {.read = php_uri_parser_rfc3986_scheme_read, .write = php_uri_parser_rfc3986_scheme_write},
+		.username = {.read = php_uri_parser_rfc3986_username_read, .write = NULL},
+		.password = {.read = php_uri_parser_rfc3986_password_read, .write = NULL},
+		.host = {.read = php_uri_parser_rfc3986_host_read, .write = php_uri_parser_rfc3986_host_write},
+		.port = {.read = php_uri_parser_rfc3986_port_read, .write = php_uri_parser_rfc3986_port_write},
+		.path = {.read = php_uri_parser_rfc3986_path_read, .write = php_uri_parser_rfc3986_path_write},
+		.query = {.read = php_uri_parser_rfc3986_query_read, .write = php_uri_parser_rfc3986_query_write},
+		.fragment = {.read = php_uri_parser_rfc3986_fragment_read, .write = php_uri_parser_rfc3986_fragment_write},
 	}
 };
diff --git a/ext/uri/uri_parser_rfc3986.h b/ext/uri/uri_parser_rfc3986.h
index 7f54b194ec366..9b976e3d211f9 100644
--- a/ext/uri/uri_parser_rfc3986.h
+++ b/ext/uri/uri_parser_rfc3986.h
@@ -20,7 +20,7 @@
 #include <uriparser/Uri.h>
 #include "php_uri_common.h"
 
-extern const uri_parser_t php_uri_parser_rfc3986;
+extern const php_uri_parser php_uri_parser_rfc3986;
 
 typedef struct php_uri_parser_rfc3986_uris {
 	UriUriA uri;
@@ -28,7 +28,7 @@ typedef struct php_uri_parser_rfc3986_uris {
 	bool normalized_uri_initialized;
 } php_uri_parser_rfc3986_uris;
 
-zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval);
+zend_result php_uri_parser_rfc3986_userinfo_read(const uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval);
 zend_result php_uri_parser_rfc3986_userinfo_write(struct uri_internal_t *internal_uri, zval *value, zval *errors);
 
 php_uri_parser_rfc3986_uris *php_uri_parser_rfc3986_parse_ex(const char *uri_str, size_t uri_str_len, const php_uri_parser_rfc3986_uris *uriparser_base_url, bool silent);
diff --git a/ext/uri/uri_parser_whatwg.c b/ext/uri/uri_parser_whatwg.c
index fb5209328bade..ad31d1d12b5b8 100644
--- a/ext/uri/uri_parser_whatwg.c
+++ b/ext/uri/uri_parser_whatwg.c
@@ -250,7 +250,7 @@ static lxb_status_t serialize_to_smart_str_callback(const lxb_char_t *data, size
 	return LXB_STATUS_OK;
 }
 
-static zend_result php_uri_parser_whatwg_scheme_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_scheme_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -277,7 +277,7 @@ static zend_result php_uri_parser_whatwg_scheme_write(struct uri_internal_t *int
 	return SUCCESS;
 }
 
-static zend_result php_uri_parser_whatwg_username_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_username_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -306,7 +306,7 @@ static zend_result php_uri_parser_whatwg_username_write(uri_internal_t *internal
 	return SUCCESS;
 }
 
-static zend_result php_uri_parser_whatwg_password_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_password_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -335,7 +335,7 @@ static zend_result php_uri_parser_whatwg_password_write(struct uri_internal_t *i
 	return SUCCESS;
 }
 
-static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -357,7 +357,7 @@ static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *
 		ZVAL_EMPTY_STRING(retval);
 	} else if (lexbor_uri->host.type != LXB_URL_HOST_TYPE__UNDEF) {
 		switch (read_mode) {
-			case URI_COMPONENT_READ_NORMALIZED_UNICODE: {
+			case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_UNICODE: {
 				smart_str host_str = {0};
 				lxb_url_serialize_host_unicode(&lexbor_idna, &lexbor_uri->host, serialize_to_smart_str_callback, &host_str);
 				lxb_unicode_idna_clean(&lexbor_idna);
@@ -365,9 +365,9 @@ static zend_result php_uri_parser_whatwg_host_read(const struct uri_internal_t *
 				ZVAL_NEW_STR(retval, smart_str_extract(&host_str));
 				break;
 			}
-			case URI_COMPONENT_READ_NORMALIZED_ASCII:
+			case PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII:
 				ZEND_FALLTHROUGH;
-			case URI_COMPONENT_READ_RAW:
+			case PHP_URI_COMPONENT_READ_MODE_RAW:
 				ZVAL_STRINGL(retval, (const char *) lexbor_uri->host.u.domain.data, lexbor_uri->host.u.domain.length);
 				break;
 			EMPTY_SWITCH_DEFAULT_CASE()
@@ -395,7 +395,7 @@ static zend_result php_uri_parser_whatwg_host_write(struct uri_internal_t *inter
 	return SUCCESS;
 }
 
-static zend_result php_uri_parser_whatwg_port_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_port_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -424,7 +424,7 @@ static zend_result php_uri_parser_whatwg_port_write(struct uri_internal_t *inter
 	return SUCCESS;
 }
 
-static zend_result php_uri_parser_whatwg_path_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_path_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -453,7 +453,7 @@ static zend_result php_uri_parser_whatwg_path_write(struct uri_internal_t *inter
 	return SUCCESS;
 }
 
-static zend_result php_uri_parser_whatwg_query_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_query_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -482,7 +482,7 @@ static zend_result php_uri_parser_whatwg_query_write(struct uri_internal_t *inte
 	return SUCCESS;
 }
 
-static zend_result php_uri_parser_whatwg_fragment_read(const struct uri_internal_t *internal_uri, uri_component_read_mode_t read_mode, zval *retval)
+static zend_result php_uri_parser_whatwg_fragment_read(const struct uri_internal_t *internal_uri, php_uri_component_read_mode read_mode, zval *retval)
 {
 	const lxb_url_t *lexbor_uri = internal_uri->uri;
 
@@ -594,21 +594,21 @@ static void *php_uri_parser_whatwg_clone(void *uri)
 	return lxb_url_clone(lexbor_parser.mraw, lexbor_uri);
 }
 
-static zend_string *php_uri_parser_whatwg_to_string(void *uri, uri_recomposition_mode_t recomposition_mode, bool exclude_fragment)
+static zend_string *php_uri_parser_whatwg_to_string(void *uri, php_uri_recomposition_mode recomposition_mode, bool exclude_fragment)
 {
 	const lxb_url_t *lexbor_uri = uri;
 	smart_str uri_str = {0};
 
 	switch (recomposition_mode) {
-		case URI_RECOMPOSITION_RAW_UNICODE:
+		case PHP_URI_RECOMPOSITION_MODE_RAW_UNICODE:
 			ZEND_FALLTHROUGH;
-		case URI_RECOMPOSITION_NORMALIZED_UNICODE:
+		case PHP_URI_RECOMPOSITION_MODE_NORMALIZED_UNICODE:
 			lxb_url_serialize_idna(&lexbor_idna, lexbor_uri, serialize_to_smart_str_callback, &uri_str, exclude_fragment);
 			lxb_unicode_idna_clean(&lexbor_idna);
 			break;
-		case URI_RECOMPOSITION_RAW_ASCII:
+		case PHP_URI_RECOMPOSITION_MODE_RAW_ASCII:
 			ZEND_FALLTHROUGH;
-		case URI_RECOMPOSITION_NORMALIZED_ASCII:
+		case PHP_URI_RECOMPOSITION_MODE_NORMALIZED_ASCII:
 			lxb_url_serialize(lexbor_uri, serialize_to_smart_str_callback, &uri_str, exclude_fragment);
 			break;
 		EMPTY_SWITCH_DEFAULT_CASE()
@@ -624,20 +624,20 @@ static void php_uri_parser_whatwg_free(void *uri)
 	lxb_url_destroy(lexbor_uri);
 }
 
-const uri_parser_t php_uri_parser_whatwg = {
+const php_uri_parser php_uri_parser_whatwg = {
 	.name = PHP_URI_PARSER_WHATWG,
-	.parse_uri = php_uri_parser_whatwg_parse,
-	.clone_uri = php_uri_parser_whatwg_clone,
-	.uri_to_string = php_uri_parser_whatwg_to_string,
-	.free_uri = php_uri_parser_whatwg_free,
+	.parse = php_uri_parser_whatwg_parse,
+	.clone = php_uri_parser_whatwg_clone,
+	.to_string = php_uri_parser_whatwg_to_string,
+	.free = php_uri_parser_whatwg_free,
 	{
-		.scheme = {.read_func = php_uri_parser_whatwg_scheme_read, .write_func = php_uri_parser_whatwg_scheme_write},
-		.username = {.read_func = php_uri_parser_whatwg_username_read, .write_func = php_uri_parser_whatwg_username_write},
-		.password = {.read_func = php_uri_parser_whatwg_password_read, .write_func = php_uri_parser_whatwg_password_write},
-		.host = {.read_func = php_uri_parser_whatwg_host_read, .write_func = php_uri_parser_whatwg_host_write},
-		.port = {.read_func = php_uri_parser_whatwg_port_read, .write_func = php_uri_parser_whatwg_port_write},
-		.path = {.read_func = php_uri_parser_whatwg_path_read, .write_func = php_uri_parser_whatwg_path_write},
-		.query = {.read_func = php_uri_parser_whatwg_query_read, .write_func = php_uri_parser_whatwg_query_write},
-		.fragment = {.read_func = php_uri_parser_whatwg_fragment_read, .write_func = php_uri_parser_whatwg_fragment_write},
+		.scheme = {.read = php_uri_parser_whatwg_scheme_read, .write = php_uri_parser_whatwg_scheme_write},
+		.username = {.read = php_uri_parser_whatwg_username_read, .write = php_uri_parser_whatwg_username_write},
+		.password = {.read = php_uri_parser_whatwg_password_read, .write = php_uri_parser_whatwg_password_write},
+		.host = {.read = php_uri_parser_whatwg_host_read, .write = php_uri_parser_whatwg_host_write},
+		.port = {.read = php_uri_parser_whatwg_port_read, .write = php_uri_parser_whatwg_port_write},
+		.path = {.read = php_uri_parser_whatwg_path_read, .write = php_uri_parser_whatwg_path_write},
+		.query = {.read = php_uri_parser_whatwg_query_read, .write = php_uri_parser_whatwg_query_write},
+		.fragment = {.read = php_uri_parser_whatwg_fragment_read, .write = php_uri_parser_whatwg_fragment_write},
 	}
 };
diff --git a/ext/uri/uri_parser_whatwg.h b/ext/uri/uri_parser_whatwg.h
index ee63e0bdf04e5..71d6ee3903bfa 100644
--- a/ext/uri/uri_parser_whatwg.h
+++ b/ext/uri/uri_parser_whatwg.h
@@ -20,7 +20,7 @@
 #include "php_uri_common.h"
 #include "lexbor/url/url.h"
 
-extern const uri_parser_t php_uri_parser_whatwg;
+extern const php_uri_parser php_uri_parser_whatwg;
 
 lxb_url_t *php_uri_parser_whatwg_parse_ex(const char *uri_str, size_t uri_str_len, const lxb_url_t *lexbor_base_url, zval *errors, bool silent);
 
diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c
index df51fa2189891..d32b55a68dea9 100644
--- a/ext/zend_test/test.c
+++ b/ext/zend_test/test.c
@@ -735,7 +735,7 @@ static ZEND_FUNCTION(zend_test_uri_parser)
 		Z_PARAM_STR(parser_name)
 	ZEND_PARSE_PARAMETERS_END();
 
-	const uri_parser_t *parser = php_uri_get_parser(parser_name);
+	const php_uri_parser *parser = php_uri_get_parser(parser_name);
 	if (parser == NULL) {
 		zend_argument_value_error(1, "Unknown parser");
 		RETURN_THROWS();
@@ -751,40 +751,40 @@ static ZEND_FUNCTION(zend_test_uri_parser)
 	array_init(return_value);
 	zval normalized;
 	array_init(&normalized);
-	php_uri_get_scheme(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_scheme(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_SCHEME), &value);
-	php_uri_get_username(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_username(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_USERNAME), &value);
-	php_uri_get_password(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_password(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_PASSWORD), &value);
-	php_uri_get_host(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_host(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_HOST), &value);
-	php_uri_get_port(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_port(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_PORT), &value);
-	php_uri_get_path(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_path(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_PATH), &value);
-	php_uri_get_query(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_query(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_QUERY), &value);
-	php_uri_get_fragment(uri, URI_COMPONENT_READ_NORMALIZED_ASCII, &value);
+	php_uri_get_fragment(uri, PHP_URI_COMPONENT_READ_MODE_NORMALIZED_ASCII, &value);
 	zend_hash_add(Z_ARR(normalized), ZSTR_KNOWN(ZEND_STR_FRAGMENT), &value);
 	zend_hash_str_add(Z_ARR_P(return_value), "normalized", strlen("normalized"), &normalized);
 	zval raw;
 	array_init(&raw);
-	php_uri_get_scheme(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_scheme(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_SCHEME), &value);
-	php_uri_get_username(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_username(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_USERNAME), &value);
-	php_uri_get_password(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_password(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_PASSWORD), &value);
-	php_uri_get_host(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_host(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_HOST), &value);
-	php_uri_get_port(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_port(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_PORT), &value);
-	php_uri_get_path(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_path(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_PATH), &value);
-	php_uri_get_query(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_query(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_QUERY), &value);
-	php_uri_get_fragment(uri, URI_COMPONENT_READ_RAW, &value);
+	php_uri_get_fragment(uri, PHP_URI_COMPONENT_READ_MODE_RAW, &value);
 	zend_hash_add(Z_ARR(raw), ZSTR_KNOWN(ZEND_STR_FRAGMENT), &value);
 	zend_hash_str_add(Z_ARR_P(return_value), "raw", strlen("raw"), &raw);
 
diff --git a/main/streams/php_stream_context.h b/main/streams/php_stream_context.h
index eb082eb1402fa..cc001cced1541 100644
--- a/main/streams/php_stream_context.h
+++ b/main/streams/php_stream_context.h
@@ -66,9 +66,9 @@ PHPAPI void php_stream_context_set_option(php_stream_context *context,
 void php_stream_context_unset_option(php_stream_context *context,
 	const char *wrappername, const char *optionname);
 
-struct uri_parser_t;
+struct php_uri_parser;
 
-PHPAPI const struct uri_parser_t *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context);
+PHPAPI const struct php_uri_parser *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context);
 PHPAPI php_stream_notifier *php_stream_notification_alloc(void);
 PHPAPI void php_stream_notification_free(php_stream_notifier *notifier);
 END_EXTERN_C()
diff --git a/main/streams/streams.c b/main/streams/streams.c
index 3a0a289e337cf..5db9cf6dadc75 100644
--- a/main/streams/streams.c
+++ b/main/streams/streams.c
@@ -2472,7 +2472,7 @@ void php_stream_context_unset_option(php_stream_context *context,
 }
 /* }}} */
 
-PHPAPI const struct uri_parser_t *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context)
+PHPAPI const struct php_uri_parser *php_stream_context_get_uri_parser(const char *wrappername, php_stream_context *context)
 {
 	if (context == NULL) {
 		return php_uri_get_parser(NULL);