@@ -13,11 +13,11 @@
  * file.
  */
 
 #include "config.h"
 
-#import "OFMutableURL.h"
+#import "OFMutableURI.h"
 #import "OFArray.h"
 #import "OFDictionary.h"
 #ifdef OF_HAVE_FILES
 # import "OFFileManager.h"
 #endif
@@ -24,80 +24,81 @@
 #import "OFNumber.h"
 #import "OFString.h"
 
 #import "OFInvalidFormatException.h"
 
-@implementation OFMutableURL
-@dynamic scheme, URLEncodedScheme, host, URLEncodedHost, port, user;
-@dynamic URLEncodedUser, password, URLEncodedPassword, path, URLEncodedPath;
-@dynamic pathComponents, query, URLEncodedQuery, queryDictionary, fragment;
-@dynamic URLEncodedFragment;
+@implementation OFMutableURI
+@dynamic scheme, percentEncodedScheme, host, percentEncodedHost, port, user;
+@dynamic percentEncodedUser, password, percentEncodedPassword, path;
+@dynamic percentEncodedPath, pathComponents, query, percentEncodedQuery;
+@dynamic queryDictionary, fragment, percentEncodedFragment;
 
-+ (instancetype)URL
++ (instancetype)URI
 {
 	return [[[self alloc] init] autorelease];
 }
 
 - (void)setScheme: (OFString *)scheme
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFString *old = _URLEncodedScheme;
+	OFString *old = _percentEncodedScheme;
 
-	_URLEncodedScheme = [[scheme stringByURLEncodingWithAllowedCharacters:
-	    [OFCharacterSet URLSchemeAllowedCharacterSet]] copy];
+	_percentEncodedScheme = [[scheme
+	    stringByAddingPercentEncodingWithAllowedCharacters:
+	    [OFCharacterSet URISchemeAllowedCharacterSet]] copy];
 
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (void)setURLEncodedScheme: (OFString *)URLEncodedScheme
+- (void)setPercentEncodedScheme: (OFString *)percentEncodedScheme
 {
 	OFString *old;
 
-	if (URLEncodedScheme != nil)
-		OFURLVerifyIsEscaped(URLEncodedScheme,
-		    [OFCharacterSet URLSchemeAllowedCharacterSet]);
+	if (percentEncodedScheme != nil)
+		OFURIVerifyIsEscaped(percentEncodedScheme,
+		    [OFCharacterSet URISchemeAllowedCharacterSet]);
 
-	old = _URLEncodedScheme;
-	_URLEncodedScheme = [URLEncodedScheme copy];
+	old = _percentEncodedScheme;
+	_percentEncodedScheme = [percentEncodedScheme copy];
 	[old release];
 }
 
 - (void)setHost: (OFString *)host
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFString *old = _URLEncodedHost;
+	OFString *old = _percentEncodedHost;
 
-	if (OFURLIsIPv6Host(host))
-		_URLEncodedHost = [[OFString alloc]
+	if (OFURIIsIPv6Host(host))
+		_percentEncodedHost = [[OFString alloc]
 		    initWithFormat: @"[%@]", host];
 	else
-		_URLEncodedHost = [[host
-		    stringByURLEncodingWithAllowedCharacters:
-		    [OFCharacterSet URLHostAllowedCharacterSet]] copy];
+		_percentEncodedHost = [[host
+		    stringByAddingPercentEncodingWithAllowedCharacters:
+		    [OFCharacterSet URIHostAllowedCharacterSet]] copy];
 
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (void)setURLEncodedHost: (OFString *)URLEncodedHost
+- (void)setPercentEncodedHost: (OFString *)percentEncodedHost
 {
 	OFString *old;
 
-	if ([URLEncodedHost hasPrefix: @"["] &&
-	    [URLEncodedHost hasSuffix: @"]"]) {
-		if (!OFURLIsIPv6Host([URLEncodedHost substringWithRange:
-		    OFMakeRange(1, URLEncodedHost.length - 2)]))
+	if ([percentEncodedHost hasPrefix: @"["] &&
+	    [percentEncodedHost hasSuffix: @"]"]) {
+		if (!OFURIIsIPv6Host([percentEncodedHost substringWithRange:
+		    OFMakeRange(1, percentEncodedHost.length - 2)]))
 			@throw [OFInvalidFormatException exception];
-	} else if (URLEncodedHost != nil)
-		OFURLVerifyIsEscaped(URLEncodedHost,
-		    [OFCharacterSet URLHostAllowedCharacterSet]);
+	} else if (percentEncodedHost != nil)
+		OFURIVerifyIsEscaped(percentEncodedHost,
+		    [OFCharacterSet URIHostAllowedCharacterSet]);
 
-	old = _URLEncodedHost;
-	_URLEncodedHost = [URLEncodedHost copy];
+	old = _percentEncodedHost;
+	_percentEncodedHost = [percentEncodedHost copy];
 	[old release];
 }
 
 - (void)setPort: (OFNumber *)port
 {
@@ -107,83 +108,85 @@
 }
 
 - (void)setUser: (OFString *)user
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFString *old = _URLEncodedUser;
+	OFString *old = _percentEncodedUser;
 
-	_URLEncodedUser = [[user stringByURLEncodingWithAllowedCharacters:
-	    [OFCharacterSet URLUserAllowedCharacterSet]] copy];
+	_percentEncodedUser = [[user
+	    stringByAddingPercentEncodingWithAllowedCharacters:
+	    [OFCharacterSet URIUserAllowedCharacterSet]] copy];
 
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (void)setURLEncodedUser: (OFString *)URLEncodedUser
+- (void)setPercentEncodedUser: (OFString *)percentEncodedUser
 {
 	OFString *old;
 
-	if (URLEncodedUser != nil)
-		OFURLVerifyIsEscaped(URLEncodedUser,
-		    [OFCharacterSet URLUserAllowedCharacterSet]);
+	if (percentEncodedUser != nil)
+		OFURIVerifyIsEscaped(percentEncodedUser,
+		    [OFCharacterSet URIUserAllowedCharacterSet]);
 
-	old = _URLEncodedUser;
-	_URLEncodedUser = [URLEncodedUser copy];
+	old = _percentEncodedUser;
+	_percentEncodedUser = [percentEncodedUser copy];
 	[old release];
 }
 
 - (void)setPassword: (OFString *)password
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFString *old = _URLEncodedPassword;
+	OFString *old = _percentEncodedPassword;
 
-	_URLEncodedPassword = [[password
-	    stringByURLEncodingWithAllowedCharacters:
-	    [OFCharacterSet URLPasswordAllowedCharacterSet]] copy];
+	_percentEncodedPassword = [[password
+	    stringByAddingPercentEncodingWithAllowedCharacters:
+	    [OFCharacterSet URIPasswordAllowedCharacterSet]] copy];
 
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (void)setURLEncodedPassword: (OFString *)URLEncodedPassword
+- (void)setPercentEncodedPassword: (OFString *)percentEncodedPassword
 {
 	OFString *old;
 
-	if (URLEncodedPassword != nil)
-		OFURLVerifyIsEscaped(URLEncodedPassword,
-		    [OFCharacterSet URLPasswordAllowedCharacterSet]);
+	if (percentEncodedPassword != nil)
+		OFURIVerifyIsEscaped(percentEncodedPassword,
+		    [OFCharacterSet URIPasswordAllowedCharacterSet]);
 
-	old = _URLEncodedPassword;
-	_URLEncodedPassword = [URLEncodedPassword copy];
+	old = _percentEncodedPassword;
+	_percentEncodedPassword = [percentEncodedPassword copy];
 	[old release];
 }
 
 - (void)setPath: (OFString *)path
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFString *old = _URLEncodedPath;
+	OFString *old = _percentEncodedPath;
 
-	_URLEncodedPath = [[path stringByURLEncodingWithAllowedCharacters:
-	    [OFCharacterSet URLPathAllowedCharacterSet]] copy];
+	_percentEncodedPath = [[path
+	    stringByAddingPercentEncodingWithAllowedCharacters:
+	    [OFCharacterSet URIPathAllowedCharacterSet]] copy];
 
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (void)setURLEncodedPath: (OFString *)URLEncodedPath
+- (void)setPercentEncodedPath: (OFString *)percentEncodedPath
 {
 	OFString *old;
 
-	if (URLEncodedPath != nil)
-		OFURLVerifyIsEscaped(URLEncodedPath,
-		    [OFCharacterSet URLPathAllowedCharacterSet]);
+	if (percentEncodedPath != nil)
+		OFURIVerifyIsEscaped(percentEncodedPath,
+		    [OFCharacterSet URIPathAllowedCharacterSet]);
 
-	old = _URLEncodedPath;
-	_URLEncodedPath = [URLEncodedPath copy];
+	old = _percentEncodedPath;
+	_percentEncodedPath = [percentEncodedPath copy];
 	[old release];
 }
 
 - (void)setPathComponents: (OFArray *)components
 {
@@ -206,104 +209,106 @@
 }
 
 - (void)setQuery: (OFString *)query
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFString *old = _URLEncodedQuery;
+	OFString *old = _percentEncodedQuery;
 
-	_URLEncodedQuery = [[query stringByURLEncodingWithAllowedCharacters:
-	    [OFCharacterSet URLQueryAllowedCharacterSet]] copy];
+	_percentEncodedQuery = [[query
+	    stringByAddingPercentEncodingWithAllowedCharacters:
+	    [OFCharacterSet URIQueryAllowedCharacterSet]] copy];
 
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (void)setURLEncodedQuery: (OFString *)URLEncodedQuery
+- (void)setPercentEncodedQuery: (OFString *)percentEncodedQuery
 {
 	OFString *old;
 
-	if (URLEncodedQuery != nil)
-		OFURLVerifyIsEscaped(URLEncodedQuery,
-		    [OFCharacterSet URLQueryAllowedCharacterSet]);
+	if (percentEncodedQuery != nil)
+		OFURIVerifyIsEscaped(percentEncodedQuery,
+		    [OFCharacterSet URIQueryAllowedCharacterSet]);
 
-	old = _URLEncodedQuery;
-	_URLEncodedQuery = [URLEncodedQuery copy];
+	old = _percentEncodedQuery;
+	_percentEncodedQuery = [percentEncodedQuery copy];
 	[old release];
 }
 
 - (void)setQueryDictionary:
     (OFDictionary OF_GENERIC(OFString *, OFString *) *)dictionary
 {
 	void *pool;
-	OFMutableString *URLEncodedQuery;
+	OFMutableString *percentEncodedQuery;
 	OFEnumerator OF_GENERIC(OFString *) *keyEnumerator, *objectEnumerator;
 	OFCharacterSet *characterSet;
 	OFString *key, *object, *old;
 
 	if (dictionary == nil) {
-		[_URLEncodedQuery release];
-		_URLEncodedQuery = nil;
+		[_percentEncodedQuery release];
+		_percentEncodedQuery = nil;
 		return;
 	}
 
 	pool = objc_autoreleasePoolPush();
-	URLEncodedQuery = [OFMutableString string];
+	percentEncodedQuery = [OFMutableString string];
 	keyEnumerator = [dictionary keyEnumerator];
 	objectEnumerator = [dictionary objectEnumerator];
-	characterSet = [OFCharacterSet URLQueryKeyValueAllowedCharacterSet];
+	characterSet = [OFCharacterSet URIQueryKeyValueAllowedCharacterSet];
 
 	while ((key = [keyEnumerator nextObject]) != nil &&
 	    (object = [objectEnumerator nextObject]) != nil) {
-		key = [key
-		    stringByURLEncodingWithAllowedCharacters: characterSet];
+		key = [key stringByAddingPercentEncodingWithAllowedCharacters:
+		    characterSet];
 		object = [object
-		    stringByURLEncodingWithAllowedCharacters: characterSet];
+		    stringByAddingPercentEncodingWithAllowedCharacters:
+		    characterSet];
 
-		if (URLEncodedQuery.length > 0)
-			[URLEncodedQuery appendString: @"&"];
+		if (percentEncodedQuery.length > 0)
+			[percentEncodedQuery appendString: @"&"];
 
-		[URLEncodedQuery appendFormat: @"%@=%@", key, object];
+		[percentEncodedQuery appendFormat: @"%@=%@", key, object];
 	}
 
-	old = _URLEncodedQuery;
-	_URLEncodedQuery = [URLEncodedQuery copy];
+	old = _percentEncodedQuery;
+	_percentEncodedQuery = [percentEncodedQuery copy];
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
 - (void)setFragment: (OFString *)fragment
 {
 	void *pool = objc_autoreleasePoolPush();
-	OFString *old = _URLEncodedFragment;
+	OFString *old = _percentEncodedFragment;
 
-	_URLEncodedFragment = [[fragment
-	    stringByURLEncodingWithAllowedCharacters:
-	    [OFCharacterSet URLFragmentAllowedCharacterSet]] copy];
+	_percentEncodedFragment = [[fragment
+	    stringByAddingPercentEncodingWithAllowedCharacters:
+	    [OFCharacterSet URIFragmentAllowedCharacterSet]] copy];
 
 	[old release];
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (void)setURLEncodedFragment: (OFString *)URLEncodedFragment
+- (void)setPercentEncodedFragment: (OFString *)percentEncodedFragment
 {
 	OFString *old;
 
-	if (URLEncodedFragment != nil)
-		OFURLVerifyIsEscaped(URLEncodedFragment,
-		    [OFCharacterSet URLFragmentAllowedCharacterSet]);
+	if (percentEncodedFragment != nil)
+		OFURIVerifyIsEscaped(percentEncodedFragment,
+		    [OFCharacterSet URIFragmentAllowedCharacterSet]);
 
-	old = _URLEncodedFragment;
-	_URLEncodedFragment = [URLEncodedFragment copy];
+	old = _percentEncodedFragment;
+	_percentEncodedFragment = [percentEncodedFragment copy];
 	[old release];
 }
 
 - (id)copy
 {
-	OFMutableURL *copy = [self mutableCopy];
+	OFMutableURI *copy = [self mutableCopy];
 
 	[copy makeImmutable];
 
 	return copy;
 }
@@ -311,19 +316,19 @@
 - (void)appendPathComponent: (OFString *)component
 {
 	[self appendPathComponent: component isDirectory: false];
 
 #ifdef OF_HAVE_FILES
-	if ([_URLEncodedScheme isEqual: @"file"] &&
-	    ![_URLEncodedPath hasSuffix: @"/"] &&
-	    [[OFFileManager defaultManager] directoryExistsAtURL: self]) {
+	if ([_percentEncodedScheme isEqual: @"file"] &&
+	    ![_percentEncodedPath hasSuffix: @"/"] &&
+	    [[OFFileManager defaultManager] directoryExistsAtURI: self]) {
 		void *pool = objc_autoreleasePoolPush();
-		OFString *path = [_URLEncodedPath
+		OFString *path = [_percentEncodedPath
 		    stringByAppendingString: @"/"];
 
-		[_URLEncodedPath release];
-		_URLEncodedPath = [path retain];
+		[_percentEncodedPath release];
+		_percentEncodedPath = [path retain];
 
 		objc_autoreleasePoolPop(pool);
 	}
 #endif
 }
@@ -332,34 +337,35 @@
 		isDirectory: (bool)isDirectory
 {
 	void *pool;
 	OFString *path;
 
-	if ([component isEqual: @"/"] && [_URLEncodedPath hasSuffix: @"/"])
+	if ([component isEqual: @"/"] && [_percentEncodedPath hasSuffix: @"/"])
 		return;
 
 	pool = objc_autoreleasePoolPush();
-	component = [component stringByURLEncodingWithAllowedCharacters:
-	    [OFCharacterSet URLPathAllowedCharacterSet]];
+	component = [component
+	    stringByAddingPercentEncodingWithAllowedCharacters:
+	    [OFCharacterSet URIPathAllowedCharacterSet]];
 
 #if defined(OF_WINDOWS) || defined(OF_MSDOS)
-	if ([_URLEncodedPath hasSuffix: @"/"] ||
-	    ([_URLEncodedScheme isEqual: @"file"] &&
-	    [_URLEncodedPath hasSuffix: @":"]))
+	if ([_percentEncodedPath hasSuffix: @"/"] ||
+	    ([_percentEncodedScheme isEqual: @"file"] &&
+	    [_percentEncodedPath hasSuffix: @":"]))
 #else
-	if ([_URLEncodedPath hasSuffix: @"/"])
+	if ([_percentEncodedPath hasSuffix: @"/"])
 #endif
-		path = [_URLEncodedPath stringByAppendingString: component];
+		path = [_percentEncodedPath stringByAppendingString: component];
 	else
-		path = [_URLEncodedPath
+		path = [_percentEncodedPath
 		    stringByAppendingFormat: @"/%@", component];
 
 	if (isDirectory && ![path hasSuffix: @"/"])
 		path = [path stringByAppendingString: @"/"];
 
-	[_URLEncodedPath release];
-	_URLEncodedPath = [path retain];
+	[_percentEncodedPath release];
+	_percentEncodedPath = [path retain];
 
 	objc_autoreleasePoolPop(pool);
 }
 
 - (void)standardizePath
@@ -367,16 +373,16 @@
 	void *pool;
 	OFMutableArray OF_GENERIC(OFString *) *array;
 	bool done = false, endsWithEmpty;
 	OFString *path;
 
-	if (_URLEncodedPath == nil)
+	if (_percentEncodedPath == nil)
 		return;
 
 	pool = objc_autoreleasePoolPush();
 
-	array = [[[_URLEncodedPath
+	array = [[[_percentEncodedPath
 	    componentsSeparatedByString: @"/"] mutableCopy] autorelease];
 
 	if ([array.firstObject length] != 0)
 		@throw [OFInvalidFormatException exception];
 
@@ -416,15 +422,15 @@
 
 	path = [array componentsJoinedByString: @"/"];
 	if (path.length == 0)
 		path = @"/";
 
-	[self setURLEncodedPath: path];
+	[self setPercentEncodedPath: path];
 
 	objc_autoreleasePoolPop(pool);
 }
 
 - (void)makeImmutable
 {
-	object_setClass(self, [OFURL class]);
+	object_setClass(self, [OFURI class]);
 }
 @end