fixes for gdc9 again

cgi.d

@@ -5848,7 +5848,9 @@ version(Posix) {
 
 // template for laziness
 void startAddonServer()(string arg) {
-	version(linux) {
+	version(OSX) {
+		assert(0, "Not implemented");
+	} else version(linux) {
 		import core.sys.posix.unistd;
 		pid_t pid;
 		const(char)*[16] args;

dom.d

@@ -158,6 +158,10 @@ class Document : FileResource {
 		return _contentType;
 	}
 
+	/// implementing the FileResource interface, useful for sending via
+	/// http automatically.
+	@property string filename() const { return null; }
+
 	/// implementing the FileResource interface, useful for sending via
 	/// http automatically.
 	override @property string contentType() const {
@@ -3939,6 +3943,13 @@ interface FileResource {
 	@property string contentType() const;
 	/// the data
 	immutable(ubyte)[] getData() const;
+	/++
+		filename, return null if none
+
+		History:
+			Added December 25, 2020
+	+/
+	@property string filename() const;
 }
 
 

http2.d

@@ -250,6 +250,16 @@ struct HttpResponse {
 	LinkHeader[] linksStored;
 	bool linksLazilyParsed;
 
+	HttpResponse deepCopy() const {
+		HttpResponse h = cast(HttpResponse) this;
+		h.cookies = h.cookies.dup;
+		h.headers = h.headers.dup;
+		h.headersHash = h.headersHash.dup;
+		h.content = h.content.dup;
+		h.linksStored = h.linksStored.dup;
+		return h;
+	}
+
 	/// Returns links header sorted by "rel" attribute.
 	/// It returns a new array on each call.
 	LinkHeader[string] linksHash() {
@@ -709,10 +719,13 @@ class HttpRequest {
 	}
 
 	///
-	this(Uri where, HttpVerb method) {
+	this(Uri where, HttpVerb method, ICache cache = null) {
 		populateFromInfo(where, method);
+		this.cache = cache;
 	}
 
+	private ICache cache;
+
 	/// Final url after any redirections
 	string finalUrl;
 
@@ -797,6 +810,16 @@ class HttpRequest {
 	private void sendPrivate(bool advance) {
 		if(state != State.unsent && state != State.aborted)
 			return; // already sent
+
+		if(cache !is null) {
+			auto res = cache.getCachedResponse(this.requestParameters);
+			if(res !is null) {
+				state = State.complete;
+				responseData = (*res).deepCopy();
+				return;
+			}
+		}
+
 		string headers;
 
 		headers ~= to!string(requestParameters.method) ~ " "~requestParameters.uri;
@@ -874,6 +897,10 @@ class HttpRequest {
 			}
 		}
 
+		if(state == State.complete && responseData.code >= 200)
+			if(cache !is null)
+				cache.cacheResponse(this.requestParameters, this.responseData);
+
 		return responseData;
 	}
 
@@ -1636,27 +1663,19 @@ class HttpClient {
 	HttpRequest navigateTo(Uri where, HttpVerb method = HttpVerb.GET) {
 		currentUrl = where.basedOn(currentUrl);
 		currentDomain = where.host;
-		auto request = new HttpRequest(currentUrl, method);
 
+		auto request = this.request(currentUrl, method);
 		request.followLocation = true;
 
-		request.requestParameters.userAgent = userAgent;
-		request.requestParameters.authorization = authorization;
-
-		request.requestParameters.useHttp11 = this.useHttp11;
-		request.requestParameters.acceptGzip = this.acceptGzip;
-		request.requestParameters.keepAlive = this.keepAlive;
-
 		return request;
 	}
 
 	/++
 		Creates a request without updating the current url state
-		(but will still save cookies btw)
-
+		(but will still save cookies btw... when that is implemented)
 	+/
 	HttpRequest request(Uri uri, HttpVerb method = HttpVerb.GET, ubyte[] bodyData = null, string contentType = null) {
-		auto request = new HttpRequest(uri, method);
+		auto request = new HttpRequest(uri, method, cache);
 
 		request.requestParameters.userAgent = userAgent;
 		request.requestParameters.authorization = authorization;
@@ -1680,8 +1699,10 @@ class HttpClient {
 
 	private Uri currentUrl;
 	private string currentDomain;
+	private ICache cache;
 
 	this(ICache cache = null) {
+		this.cache = cache;
 
 	}
 
@@ -1713,22 +1734,115 @@ class HttpClient {
 }
 
 interface ICache {
-	HttpResponse* getCachedResponse(HttpRequestParameters request);
+	/++
+		The client is about to make the given `request`. It will ALWAYS pass it to the cache object first so you can decide if you want to and can provide a response. You should probably check the appropriate headers to see if you should even attempt to look up on the cache (HttpClient does NOT do this to give maximum flexibility to the cache implementor).
+
+		Return null if the cache does not provide.
+	+/
+	const(HttpResponse)* getCachedResponse(HttpRequestParameters request);
+
+	/++
+		The given request has received the given response. The implementing class needs to decide if it wants to cache or not. Return true if it was added, false if you chose not to.
+
+		You may wish to examine headers, etc., in making the decision. The HttpClient will ALWAYS pass a request/response to this.
+	+/
+	bool cacheResponse(HttpRequestParameters request, HttpResponse response);
 }
 
+/+
 // / Provides caching behavior similar to a real web browser
 class HttpCache : ICache {
-	HttpResponse* getCachedResponse(HttpRequestParameters request) {
+	const(HttpResponse)* getCachedResponse(HttpRequestParameters request) {
 		return null;
 	}
 }
  
 // / Gives simple maximum age caching, ignoring the actual http headers
 class SimpleCache : ICache {
-	HttpResponse* getCachedResponse(HttpRequestParameters request) {
+	const(HttpResponse)* getCachedResponse(HttpRequestParameters request) {
 		return null;
 	}
 }
++/
+
+/++
+	A pseudo-cache to provide a mock server. Construct one of these,
+	populate it with test responses, and pass it to [HttpClient] to
+	do a network-free test.
+
+	You should populate it with the [populate] method. Any request not
+	pre-populated will return a "server refused connection" response.
++/
+class HttpMockProvider : ICache {
+	/++
+
+	+/
+	this(Uri baseUrl, string defaultResponseContentType) {
+
+	}
+
+	this() {}
+
+	HttpResponse defaultResponse;
+
+	const(HttpResponse)* getCachedResponse(HttpRequestParameters request) {
+		import std.conv;
+		auto defaultPort = request.ssl ? 443 : 80;
+		string identifier = text(
+			request.method, " ",
+			request.ssl ? "https" : "http", "://",
+			request.host,
+			(request.port && request.port != defaultPort) ? (":" ~ to!string(request.port)) : "",
+			request.uri
+		);
+
+		if(auto res = identifier in population)
+			return res;
+		return &defaultResponse;
+	}
+
+	// we never actually cache anything here since it is all about mock responses
+	bool cacheResponse(HttpRequestParameters request, HttpResponse response) {
+		return false;
+	}
+
+	/++
+		Convenience method to populate simple responses. For more complex
+		work, use one of the other overloads where you build complete objects
+		yourself.
+
+		Params:
+			request = a verb and complete URL to mock as one string.
+			For example "GET http://example.com/". If you provide only
+			a partial URL, it will be based on the `baseUrl` you gave
+			in the `HttpMockProvider` constructor.
+
+			responseCode = the HTTP response code, like 200 or 404.
+
+			response = the response body as a string. It is assumed
+			to be of the `defaultResponseContentType` you passed in the
+			`HttpMockProvider` constructor.
+	+/
+	void populate(string request, int responseCode, string response) {
+
+		// FIXME: absolute-ize the URL in the request
+
+		HttpResponse r;
+		r.code = responseCode;
+		r.codeText = "Mocked"; // FIXME
+
+		r.content = cast(ubyte[]) response;
+		r.contentText = response;
+
+		population[request] = r;
+	}
+
+	void populate(string method, string url, HttpResponse response) {
+		// FIXME
+	}
+
+	private HttpResponse[string] population;
+}
 
 ///
 struct HttpCookie {
@@ -2601,7 +2715,7 @@ class WebSocket {
 			used = used[1 .. $];
 
 		if(used.length == 0)
-			throw new Exception("wtf");
+			throw new Exception("Remote server disconnected or didn't send enough information");
 
 		if(used.length < 1)
 			more();
@@ -2726,9 +2840,12 @@ class WebSocket {
 	}
 
 	private void llsend(ubyte[] d) {
+		if(readyState == CONNECTING)
+			throw new Exception("WebSocket not connected when trying to send. Did you forget to call connect(); ?");
+			//connect();
 		while(d.length) {
 			auto r = socket.send(d);
-			if(r <= 0) throw new Exception("wtf");
+			if(r <= 0) throw new Exception("Socket send failed");
 			d = d[r .. $];
 		}
 	}
@@ -2744,11 +2861,13 @@ class WebSocket {
 	+/
 	/// Group: blocking_api
 	public bool lowLevelReceive() {
+		if(readyState == CONNECTING)
+			throw new Exception("WebSocket not connected when trying to receive. Did you forget to call connect(); ?");
 		auto r = socket.receive(receiveBuffer[receiveBufferUsedLength .. $]);
 		if(r == 0)
 			return false;
 		if(r <= 0)
-			throw new Exception("wtf");
+			throw new Exception("Socket receive failed");
 		receiveBufferUsedLength += r;
 		return true;
 	}

jsvar.d

@@ -2030,6 +2030,8 @@ interface ScriptableSubclass {
 	History:
 	Added April 25, 2020
 +/
+static if(__traits(compiles, mixin(q{  () { static foreach(i; [1,2]) {} } }) ))
+mixin(q{
 var subclassable(T)() if(is(T == class) || is(T == interface)) {
 	import std.traits;
 
@@ -2086,6 +2088,7 @@ var subclassable(T)() if(is(T == class) || is(T == interface)) {
 
 	return f;
 }
+});
 
 /// Demonstrates tested capabilities of [subclassable]
 version(with_arsd_script)
@@ -2519,10 +2522,13 @@ class OverloadSet : PrototypeObject {
 	}
 
 	///
+	static if(__traits(compiles, mixin(q{  () { static foreach(i; [1,2]) {} } }) ))
+	mixin(q{
 	void addOverloadsOf(alias what)() {
 		foreach(alias f; __traits(getOverloads, __traits(parent, what), __traits(identifier, what)))
 			addIndividualOverload!f;
 	}
+	});
 
 	static struct Overload {
 		// I don't even store the arity of a function object

sslsocket.d

@@ -100,7 +100,7 @@ version(use_openssl) {
 				ERR_print_errors_fp(stderr);
 				int i;
 				printf("wtf\n");
-				scanf("%d\n", i);
+				scanf("%d\n", &i);
 				throw new Exception("ssl connect");
 			}
 		}
@@ -112,7 +112,7 @@ version(use_openssl) {
 				ERR_print_errors_fp(stderr);
 				int i;
 				printf("wtf\n");
-				scanf("%d\n", i);
+				scanf("%d\n", &i);
 				throw new Exception("ssl send");
 			}
 			return retval;
@@ -128,7 +128,7 @@ version(use_openssl) {
 				ERR_print_errors_fp(stderr);
 				int i;
 				printf("wtf\n");
-				scanf("%d\n", i);
+				scanf("%d\n", &i);
 				throw new Exception("ssl send");
 			}
 			return retval;

terminal.d

@@ -2126,7 +2126,9 @@ struct Terminal {
 inout(char)[] removeTerminalGraphicsSequences(inout(char)[] s) {
 	import std.string;
 
-	auto at = s.indexOf("\033[");
+	// on old compilers, inout index of fails, but const works, so i'll just
+	// cast it, this is ok since inout and const work the same regardless
+	auto at = (cast(const(char)[])s).indexOf("\033[");
 	if(at == -1)
 		return s;
 
@@ -2140,7 +2142,7 @@ inout(char)[] removeTerminalGraphicsSequences(inout(char)[] s) {
 		}
 		if(s.length)
 			s = s[1 .. $]; // skip the terminator
-		at = s.indexOf("\033[");
+		at = (cast(const(char)[])s).indexOf("\033[");
 	} while(at != -1);
 
 	ret ~= s;

web.d

@@ -779,6 +779,8 @@ class DataFile : FileResource {
 		return _contentType;
 	}
 
+	@property string filename() const { return null; }
+
 	immutable(ubyte)[] getData() const {
 		return cast(immutable(ubyte)[]) _content;
 	}