static final String BUILTIN_HANDLERS_PREFIX = "sun.net.www.protocol";

@java.io.Serial

static final long serialVersionUID = -7627629688361524110L;

/**

private static final String protocolPathProp = "java.protocol.handler.pkgs";

/**

private String protocol;

/**

private String host;

/**

private int port = -1;

/**

private String file;

/**

private transient String query;

/**

private String authority;

/**

private transient String path;

/**

private transient String userInfo;

/**

private String ref;

/**

private transient InetAddress hostAddress;

/**

transient URLStreamHandler handler;

/* Our hash code.

private int hashCode = -1;

private transient UrlDeserializedState tempState;

/**

@Deprecated(since = "20")

public URL(String protocol, String host, int port, String file)

throws MalformedURLException

{

this(protocol, host, port, file, null);

}

/**

@Deprecated(since = "20")

public URL(String protocol, String host, String file)

throws MalformedURLException {

this(protocol, host, -1, file);

}

/**

@Deprecated(since = "20")

public URL(String protocol, String host, int port, String file,

URLStreamHandler handler) throws MalformedURLException {

protocol = lowerCaseProtocol(protocol);

this.protocol = protocol;

if (host != null) {

/**

if (host.indexOf(':') >= 0 && !host.startsWith("[")) {

host = "["+host+"]";

}

this.host = host;

if (port < -1) {

throw new MalformedURLException("Invalid port number :" +

port);

}

this.port = port;

authority = (port == -1) ? host : host + ":" + port;

}

int index = file.indexOf('#');

this.ref = index < 0 ? null : file.substring(index + 1);

file = index < 0 ? file : file.substring(0, index);

int q = file.lastIndexOf('?');

if (q != -1) {

this.query = file.substring(q + 1);

this.path = file.substring(0, q);

this.file = path + "?" + query;

} else {

this.path = file;

this.file = path;

}

// Note: we don't do full validation of the URL here. Too risky to change

// right now, but worth considering for future reference. -br

if (handler == null &&

(handler = getURLStreamHandler(protocol)) == null) {

throw new MalformedURLException("unknown protocol: " + protocol);

}

this.handler = handler;

if (host != null && isBuiltinStreamHandler(handler)) {

String s = IPAddressUtil.checkExternalForm(this);

if (s != null) {

throw new MalformedURLException(s);

}

}

if ("jar".equalsIgnoreCase(protocol)) {

if (handler instanceof sun.net.www.protocol.jar.Handler) {

// URL.openConnection() would throw a confusing exception

// so generate a better exception here instead.

String s = ((sun.net.www.protocol.jar.Handler) handler).checkNestedProtocol(file);

if (s != null) {

throw new MalformedURLException(s);

}

}

}

}

/**

@Deprecated(since = "20")

public URL(String spec) throws MalformedURLException {

this(null, spec);

}

/**

@Deprecated(since = "20")

public URL(URL context, String spec) throws MalformedURLException {

this(context, spec, null);

}

/**

@Deprecated(since = "20")

public URL(URL context, String spec, URLStreamHandler handler)

throws MalformedURLException

{

String original = spec;

int i, limit, c;

int start = 0;

String newProtocol = null;

boolean aRef=false;

boolean isRelative = false;

try {

limit = spec.length();

while ((limit > 0) && (spec.charAt(limit - 1) <= ' ')) {

limit--; //eliminate trailing whitespace

}

while ((start < limit) && (spec.charAt(start) <= ' ')) {

start++; // eliminate leading whitespace

}

if (spec.regionMatches(true, start, "url:", 0, 4)) {

start += 4;

}

if (start < spec.length() && spec.charAt(start) == '#') {

/* we're assuming this is a ref relative to the context URL.

aRef=true;

}

for (i = start ; !aRef && (i < limit) &&

((c = spec.charAt(i)) != '/') ; i++) {

if (c == ':') {

String s = lowerCaseProtocol(spec.substring(start, i));

if (isValidProtocol(s)) {

newProtocol = s;

start = i + 1;

}

break;

}

}

// Only use our context if the protocols match.

protocol = newProtocol;

if ((context != null) && ((newProtocol == null) ||

newProtocol.equalsIgnoreCase(context.protocol))) {

// inherit the protocol handler from the context

// if not specified to the constructor

if (handler == null) {

handler = context.handler;

}

// If the context is a hierarchical URL scheme and the spec

// contains a matching scheme then maintain backwards

// compatibility and treat it as if the spec didn't contain

// the scheme; see 5.2.3 of RFC2396

if (context.path != null && context.path.startsWith("/"))

newProtocol = null;

if (newProtocol == null) {

protocol = context.protocol;

authority = context.authority;

userInfo = context.userInfo;

host = context.host;

port = context.port;

file = context.file;

path = context.path;

isRelative = true;

}

}

if (protocol == null) {

throw new MalformedURLException("no protocol: "+original);

}

// Get the protocol handler if not specified or the protocol

// of the context could not be used

if (handler == null &&

(handler = getURLStreamHandler(protocol)) == null) {

throw new MalformedURLException("unknown protocol: "+protocol);

}

this.handler = handler;

i = spec.indexOf('#', start);

if (i >= 0) {

ref = spec.substring(i + 1, limit);

limit = i;

}

/*

if (isRelative && start == limit) {

query = context.query;

if (ref == null) {

ref = context.ref;

}

}

handler.parseURL(this, spec, start, limit);

} catch(MalformedURLException e) {

throw e;

} catch(Exception e) {

MalformedURLException exception = new MalformedURLException(e.getMessage());

exception.initCause(e);

throw exception;

}

}

/**

public static URL of(URI uri, URLStreamHandler handler)

throws MalformedURLException {

if (!uri.isAbsolute()) {

throw new IllegalArgumentException("URI is not absolute");

}

String protocol = uri.getScheme();

// fast path for canonical jrt:/... URLs

//

// In general we need to go via Handler.parseURL, but for the jrt

// protocol we enforce that the Handler is not overridable and can

// optimize URI to URL conversion.

//

// Case-sensitive comparison for performance; malformed protocols will

// be handled correctly by the slow path.

if (handler == null && protocol.equals("jrt") && !uri.isOpaque()

&& uri.getRawAuthority() == null

&& uri.getRawFragment() == null) {

String query = uri.getRawQuery();

String path = uri.getRawPath();

String file = (query == null) ? path : path + "?" + query;

// URL represent undefined host as empty string while URI use null

String host = uri.getHost();

if (host == null) {

host = "";

}

int port = uri.getPort();

return new URL("jrt", host, port, file, null);

}

// slow path (will work for non-canonical forms of jrt: too)

if ("url".equalsIgnoreCase(protocol)) {;

String uristr = uri.toString();

try {

URI inner = new URI(uristr.substring(4));

if (inner.isAbsolute()) {

protocol = inner.getScheme();

}

} catch (URISyntaxException use) {

throw new MalformedURLException(use.getMessage());

}

}

if (handler != null && !isOverrideable(protocol)) {

throw new IllegalArgumentException("Can't override URLStreamHandler for protocol "

+ protocol);

}

return new URL((URL)null, uri.toString(), handler);

}

/*

private boolean isValidProtocol(String protocol) {

int len = protocol.length();

if (len < 1)

return false;

char c = protocol.charAt(0);

if (!Character.isLetter(c))

return false;

for (int i = 1; i < len; i++) {

c = protocol.charAt(i);

if (!Character.isLetterOrDigit(c) && c != '.' && c != '+' &&

c != '-') {

return false;

}

}

return true;

}

/**

void set(String protocol, String host, int port,

String authority, String userInfo, String path,

String query, String ref) {

synchronized (this) {

this.protocol = protocol;

this.host = host;

this.port = port;

this.file = query == null ? path : path + "?" + query;

this.userInfo = userInfo;

this.path = path;

this.ref = ref;

/* This is very important. We must recompute this after the

hashCode = -1;

hostAddress = null;

this.query = query;

this.authority = authority;

}

}

/**

synchronized InetAddress getHostAddress() {

if (hostAddress != null) {

return hostAddress;

}

if (host == null || host.isEmpty()) {

return null;

}

try {

hostAddress = InetAddress.getByName(host);

} catch (UnknownHostException e) {

return null;

}

return hostAddress;

}

/**

public String getQuery() {

return query;

}

/**

public String getPath() {

return path;

}

/**

public String getUserInfo() {

return userInfo;

}

/**

public String getAuthority() {

return authority;

}

/**

public int getPort() {

return port;

}