dmd 2.065

2014-02-24 13:14:20 -05:00 · 2014-02-24 13:14:20 -05:00 · 68b9a610aa
parent bd1e3cc2d0
commit 68b9a610aa
15 changed files with 777 additions and 155 deletions
--- a/color.d
+++ b/color.d
@ -122,6 +122,8 @@ struct Color {
 			ubyte b; /// blue
 			ubyte a; /// alpha. 255 == opaque
 		}
+
+		uint asUint;
 	}

 	// this makes sure they are in range before casting
@ -176,7 +178,12 @@ struct Color {
 		if(a == 255)
 			return toCssString()[1 .. $];
 		else
-			return toHexInternal(r) ~ toHexInternal(g) ~ toHexInternal(b) ~ toHexInternal(a);
+			return toRgbaHexString();
+	}
+
+	/// returns RRGGBBAA, even if a== 255
+	string toRgbaHexString() {
+		return toHexInternal(r) ~ toHexInternal(g) ~ toHexInternal(b) ~ toHexInternal(a);
 	}

 	/// Gets a color by name, iff the name is one of the static members listed above
@ -760,6 +767,15 @@ class IndexedImage : MemoryImage {
 	TrueColorImage convertToTrueColor() const {
 		auto tci = new TrueColorImage(width, height);
 		foreach(i, b; data) {
+			/*
+			if(b >= palette.length) {
+				string fuckyou;
+				fuckyou ~= b + '0';
+				fuckyou ~= " ";
+				fuckyou ~= palette.length + '0';
+				assert(0, fuckyou);
+			}
+			*/
 			tci.imageData.colors[i] = palette[b];
 		}
 		return tci;
--- a/curl.d
+++ b/curl.d
@ -67,7 +67,10 @@ struct CurlOptions {

 string getDigestString(string s) {
 	import std.digest.md;
-	return toHexString(md5Of(s));
+	import std.digest.digest;
+	auto hash = md5Of(s);
+	auto a = toHexString(hash);
+	return a.idup;
 }
 //import std.md5;
 import std.file;
--- a/database.d
+++ b/database.d
@ -21,6 +21,19 @@ interface Database {
 	/// Just executes a query. It supports placeholders for parameters
 	/// by using ? in the sql string. NOTE: it only accepts string, int, long, and null types.
 	/// Others will fail runtime asserts.
+	final ResultSet query(T...)(string sql, T t) {
+		Variant[] args;
+		foreach(arg; t) {
+			Variant a;
+			static if(__traits(compiles, a = arg))
+				a = arg;
+			else
+				a = to!string(t);
+			args ~= a;
+		}
+		return queryImpl(sql, args);
+	}
+	version(none)
 	final ResultSet query(string sql, ...) {
 		Variant[] args;
 		foreach(arg; _arguments) {
@ -440,11 +453,14 @@ enum UpdateOrInsertMode {

 // BIG FIXME: this should really use prepared statements
 int updateOrInsert(Database db, string table, string[string] values, string where, UpdateOrInsertMode mode = UpdateOrInsertMode.CheckForMe, string key = "id") {
+
+	string identifierQuote = "";
+
 	bool insert = false;

 	final switch(mode) {
 		case UpdateOrInsertMode.CheckForMe:
-			auto res = db.query("SELECT "~key~" FROM `"~db.escape(table)~"` WHERE " ~ where);
+			auto res = db.query("SELECT "~key~" FROM "~identifierQuote~db.escape(table)~identifierQuote~" WHERE " ~ where);
 			insert = res.empty;

 		break;
@ -458,7 +474,7 @@ int updateOrInsert(Database db, string table, string[string] values, string wher


 	if(insert) {
-		string insertSql = "INSERT INTO `" ~ db.escape(table) ~ "` ";
+		string insertSql = "INSERT INTO " ~identifierQuote ~ db.escape(table) ~ identifierQuote ~ " ";

 		bool outputted = false;
 		string vs, cs;
@ -472,7 +488,7 @@ int updateOrInsert(Database db, string table, string[string] values, string wher
 				outputted = true;

 			//cs ~= "`" ~ db.escape(column) ~ "`";
-			cs ~= "`" ~ column ~ "`"; // FIXME: possible insecure
+			cs ~= identifierQuote ~ column ~ identifierQuote; // FIXME: possible insecure
 			if(value is null)
 				vs ~= "NULL";
 			else
@ -491,7 +507,7 @@ int updateOrInsert(Database db, string table, string[string] values, string wher

 		return 0; // db.lastInsertId;
 	} else {
-		string updateSql = "UPDATE `"~db.escape(table)~"` SET ";
+		string updateSql = "UPDATE "~identifierQuote~db.escape(table)~identifierQuote~" SET ";

 		bool outputted = false;
 		foreach(column, value; values) {
@ -503,9 +519,9 @@ int updateOrInsert(Database db, string table, string[string] values, string wher
 				outputted = true;

 			if(value is null)
-				updateSql ~= "`" ~ db.escape(column) ~ "` = NULL";
+				updateSql ~= identifierQuote ~ db.escape(column) ~ identifierQuote ~ " = NULL";
 			else
-				updateSql ~= "`" ~ db.escape(column) ~ "` = '" ~ db.escape(value) ~ "'";
+				updateSql ~= identifierQuote ~ db.escape(column) ~ identifierQuote ~ " = '" ~ db.escape(value) ~ "'";
 		}

 		if(!outputted)
@ -641,13 +657,15 @@ class DataObject {

 	JSONValue makeJsonValue() {
 		JSONValue val;
-		val.type = JSON_TYPE.OBJECT;
+		JSONValue[string] valo;
+		//val.type = JSON_TYPE.OBJECT;
 		foreach(k, v; fields) {
 			JSONValue s;
-			s.type = JSON_TYPE.STRING;
+			//s.type = JSON_TYPE.STRING;
 			s.str = v;
-			val.object[k] = s;
+			valo[k] = s;
 		}
+		val = valo;
 		return val;
 	}

@ -714,6 +732,9 @@ class DataObject {
 			} else if (arg == typeid(char) || arg == typeid(immutable(char))) {
 				auto e = va_arg!(char)(_argptr);
 				a = to!string(e);
+			} else if (arg == typeid(uint) || arg == typeid(immutable(uint)) || arg == typeid(const(uint))) {
+				auto e = va_arg!uint(_argptr);
+				a = to!string(e);
 			} else if (arg == typeid(long) || arg == typeid(const(long)) || arg == typeid(immutable(long))) {
 				auto e = va_arg!(long)(_argptr);
 				a = to!string(e);
--- a/dom.d
+++ b/dom.d
@ -2289,6 +2289,8 @@ dchar parseEntity(in dchar[] entity) {
 		case "tilde": return '\u02DC';
 		case "trade": return '\u2122';

+		case "hellip": return '\u2026';
+		case "mdash": return '\u2014';

 		/*
 		case "cent":
@ -2328,8 +2330,7 @@ dchar parseEntity(in dchar[] entity) {
 			return '\u00a9';
 		case "eacute":
 			return '\u00e9';
-		case "mdash":
-			return '\u2014';
+		case "mdash": return '\u2014';
 		case "ndash":
 			return '\u2013';
 		case "Omicron":
--- a/html.d
+++ b/html.d
@ -242,6 +242,24 @@ Html linkify(string text) {
 	return Html(div.innerHTML);
 }

+// your things should already be encoded
+Html paragraphsToP(Html html) {
+	auto text = html.source;
+	string total;
+	foreach(p; text.split("\n\n")) {
+		total ~= "<p>";
+		auto lines = p.splitLines;
+		foreach(idx, line; lines)
+			if(line.strip.length) {
+				total ~= line;
+				if(idx != lines.length - 1)
+					total ~= "<br />";
+			}
+		total ~= "</p>";
+	}
+	return Html(total);
+}
+
 Html nl2br(string text) {
 	auto div = Element.make("div");

--- a/http.d
+++ b/http.d
@ -1,4 +1,7 @@
-module arsd.http;
+// Copyright 2013, Adam D. Ruppe. All Rights Reserved.
+module arsd.http2;
+
+// FIXME: check Transfer-Encoding: gzip always

 version(with_openssl) {
 	pragma(lib, "crypto");
@ -366,3 +369,299 @@ void main(string args[]) {
 	write(post("http://arsdnet.net/bugs.php", ["test" : "hey", "again" : "what"]));
 }
 */
+
+struct Url {
+	string url;
+}
+
+struct BasicAuth {
+	string username;
+	string password;
+}
+
+/*
+	When you send something, it creates a request
+	and sends it asynchronously. The request object
+
+	auto request = new HttpRequest();
+	// set any properties here
+
+	// synchronous usage
+	auto reply = request.perform();
+
+	// async usage, type 1:
+	request.send();
+	request2.send();
+
+	// wait until the first one is done, with the second one still in-flight
+	auto response = request.waitForCompletion();
+
+
+	// async usage, type 2:
+	request.onDataReceived = (HttpRequest hr) {
+		if(hr.state == HttpRequest.State.complete) {
+			// use hr.responseData
+		}
+	};
+	request.send(); // send, using the callback
+
+	// before terminating, be sure you wait for your requests to finish!
+
+	request.waitForCompletion();
+
+*/
+
+class HttpRequest {
+	private static {
+		// we manage the actual connections. When a request is made on a particular
+		// host, we try to reuse connections. We may open more than one connection per
+		// host to do parallel requests.
+		//
+		// The key is the *domain name*. Multiple domains on the same address will have separate connections.
+		Socket[][string] socketsPerHost;
+
+		// only one request can be active on a given socket (at least HTTP < 2.0) so this is that
+		HttpRequest[Socket] activeRequestOnSocket;
+		HttpRequest[] pending; // and these are the requests that are waiting
+
+		SocketSet readSet;
+
+
+		void advanceConnections() {
+			if(readSet is null)
+				readSet = new SocketSet();
+
+			// are there pending requests? let's try to send them
+
+			readSet.reset();
+
+			// active requests need to be read or written to
+			foreach(sock, request; activeRequestOnSocket)
+				readSet.add(sock);
+
+			// check the other sockets just for EOF, if they close, take them out of our list,
+			// we'll reopen if needed upon request.
+
+			auto got = Socket.select(readSet, writeSet, null, 10.seconds /* timeout */);
+			if(got == 0) /* timeout */
+				{}
+			else
+			if(got == -1) /* interrupted */
+				{}
+			else /* ready */
+				{}
+
+			// call select(), do what needs to be done
+			// no requests are active, send the ones pending connection now
+			// we've completed a request, are there any more pending connection? if so, send them now
+
+			auto readSet = new SocketSet();
+		}
+	}
+
+	this() {
+		addConnection(this);
+	}
+
+	~this() {
+		removeConnection(this);
+	}
+
+	HttpResponse responseData;
+	HttpRequestParameters parameters;
+	private HttpClient parentClient;
+
+	size_t bodyBytesSent;
+	size_t bodyBytesReceived;
+
+	State state;
+	/// Called when data is received. Check the state to see what data is available.
+	void delegate(AsynchronousHttpRequest) onDataReceived;
+
+	enum State {
+		/// The request has not yet been sent
+		unsent,
+
+		/// The send() method has been called, but no data is
+		/// sent on the socket yet because the connection is busy.
+		pendingAvailableConnection,
+
+		/// The headers are being sent now
+		sendingHeaders,
+
+		/// The body is being sent now
+		sendingBody,
+
+		/// The request has been sent but we haven't received any response yet
+		waitingForResponse,
+
+		/// We have received some data and are currently receiving headers
+		readingHeaders,
+
+		/// All headers are available but we're still waiting on the body
+		readingBody,
+
+		/// The request is complete.
+		complete,
+
+		/// The request is aborted, either by the abort() method, or as a result of the server disconnecting
+		aborted
+	}
+
+	/// Sends now and waits for the request to finish, returning the response.
+	HttpResponse perform() {
+		send();
+		return waitForCompletion();
+	}
+
+	/// Sends the request asynchronously.
+	void send() {
+		if(state != State.unsent && state != State.aborted)
+			return; // already sent
+
+		responseData = HttpResponse.init;
+		bodyBytesSent = 0;
+		bodyBytesReceived = 0;
+		state = State.pendingAvailableConnection;
+
+		HttpResponse.advanceConnections();
+	}
+
+
+	/// Waits for the request to finish or timeout, whichever comes furst.
+	HttpResponse waitForCompletion() {
+		while(state != State.aborted && state != State.complete)
+			HttpResponse.advanceConnections();
+		return responseData;
+	}
+
+	/// Aborts this request.
+	/// Due to the nature of the HTTP protocol, aborting one request will result in all subsequent requests made on this same connection to be aborted as well.
+	void abort() {
+		parentClient.close();
+	}
+}
+
+struct HttpRequestParameters {
+	Duration timeout;
+
+	// debugging
+	bool useHttp11 = true;
+	bool acceptGzip = true;
+
+	// the request itself
+	HttpVerb method;
+	string host;
+	string uri;
+
+	string userAgent;
+
+	string[string] cookies;
+
+	string[] headers; /// do not duplicate host, content-length, content-type, or any others that have a specific property
+
+	string contentType;
+	ubyte[] bodyData;
+}
+
+interface IHttpClient {
+
+}
+
+enum HttpVerb { GET, HEAD, POST, PUT, DELETE, OPTIONS, TRACE, CONNECT }
+
+/*
+	Usage:
+
+	auto client = new HttpClient("localhost", 80);
+	// relative links work based on the current url
+	client.get("foo/bar");
+	client.get("baz"); // gets foo/baz
+
+	auto request = client.get("rofl");
+	auto response = request.waitForCompletion();
+*/
+
+/// HttpClient keeps cookies, location, and some other state to reuse connections, when possible, like a web browser.
+class HttpClient {
+	/* Protocol restrictions, useful to disable when debugging servers */
+	bool useHttp11 = true;
+	bool useGzip = true;
+
+	/// Automatically follow a redirection?
+	bool followLocation = false;
+
+	@property Url location() {
+		return currentUrl;
+	}
+
+	/// High level function that works similarly to entering a url
+	/// into a browser.
+	///
+	/// Follows locations, updates the current url.
+	AsynchronousHttpRequest navigateTo(Url where) {
+		currentUrl = where.basedOn(currentUrl);
+		assert(0);
+	}
+
+	private Url currentUrl;
+
+	this() {
+
+	}
+
+	this(Url url) {
+		open(url);
+	}
+
+	this(string host, ushort port = 80, bool useSsl = false) {
+		open(host, port);
+	}
+
+	// FIXME: add proxy
+	// FIXME: some kind of caching
+
+	void open(Url url) {
+
+	}
+
+	void open(string host, ushort port = 80, bool useSsl = false) {
+
+	}
+
+	void close() {
+		socket.close();
+	}
+
+	void setCookie(string name, string value) {
+
+	}
+
+	void clearCookies() {
+
+	}
+
+	HttpResponse sendSynchronously() {
+		auto request = sendAsynchronously();
+		return request.waitForCompletion();
+	}
+
+	AsynchronousHttpRequest sendAsynchronously() {
+
+	}
+
+	string method;
+	string host;
+	ushort port;
+	string uri;
+
+	string[] headers;
+	ubyte[] requestBody;
+
+	string userAgent;
+
+	/* inter-request state */
+	string[string] cookies;
+}
+
+// FIXME: websocket
--- a/jsvar.d
+++ b/jsvar.d
@ -1,3 +1,15 @@
+/*
+	FIXME:
+		pointer to member functions can give a way to wrap things
+
+		we'll pass it an opaque object as this and it will unpack and call the method
+
+		we can also auto-generate getters and setters for properties with this method
+
+		and constructors, so the script can create class objects too
+*/
+
+
 /**
 	jsvar provides a D type called 'var' that works similarly to the same in Javascript.

@ -32,6 +44,8 @@
 */
 module arsd.jsvar;

+version=new_std_json;
+
 import std.stdio;
 import std.traits;
 import std.conv;
@ -110,6 +124,9 @@ version(test_script)
 	}
 version(test_script)
 void main() {
+import arsd.script;
+writeln(interpret("x*x + 3*x;", var(["x":3])));
+
 	{
 	var a = var.emptyObject;
 	a.qweq = 12;
@ -571,6 +588,9 @@ struct var {
 			this._payload._integral = t;
 		} else static if(isCallable!T) {
 			this._type = Type.Function;
+			static if(is(T == typeof(this._payload._function))) {
+				this._payload._function = t;
+			} else
 			this._payload._function = delegate var(var _this, var[] args) {
 				var ret;

@ -780,6 +800,12 @@ struct var {
 		}
 	}

+	public T nullCoalesce(T)(T t) {
+		if(_type == Type.Object && _payload._object is null)
+			return t;
+		return this.get!T;
+	}
+
 	public int opCmp(T)(T t) {
 		auto f = this.get!real;
 		static if(is(T == var))
@ -1062,7 +1088,6 @@ struct var {
 				assert(_arrayPrototype._type == Type.Object);
 				if(_arrayPrototype._payload._object is null) {
 					_arrayPrototype._object = new PrototypeObject();
-					writeln("ctor on ", payloadType());
 				}

 				return _arrayPrototype;
--- a/oauth.d
+++ b/oauth.d
@ -31,8 +31,7 @@ class FacebookApiException : Exception {
 import arsd.curl;
 import arsd.sha;

-import std.md5;
-// import std.digest.md;
+import std.digest.md;

 import std.file;

@ -74,60 +73,43 @@ Variant[string] postToFacebookWall(string[] info, string id, string message, str
 	}

 	return var;
-
 }

-// note ids=a,b,c works too. it returns an associative array of the ids requested.
-Variant[string] fbGraph(string[] info, string id, bool useCache = false, long maxCacheHours = 2) {
-	string response;
+version(with_arsd_jsvar) {
+	import arsd.jsvar;
+	var fbGraph(string token, string id, bool useCache = false, long maxCacheHours = 2) {
+		auto response = fbGraphImpl(token, id, useCache, maxCacheHours);

-	string cacheFile;
+		var ret = var.emptyObject;

-	char c = '?';
-
-	if(id.indexOf("?") != -1)
-		c = '&';
-
-	string url;
-
-	if(id[0] != '/')
-		id = "/" ~ id;
-	
-	if(info !is null)
-		url = "https://graph.facebook.com" ~ id
-			~ c ~ "access_token=" ~ info[1] ~ "&format=json";
-	else
-		url = "http://graph.facebook.com" ~ id
-			~ c ~ "format=json";
-
-	// this makes pagination easier. the initial / is there because it is added above
-	if(id.indexOf("/http://") == 0 || id.indexOf("/https://") == 0)
-		url = id[1 ..$];
-
-	if(useCache)
-		cacheFile = "/tmp/fbGraphCache-" ~ hashToString(SHA1(url));
-
-	if(useCache) {
-		if(std.file.exists(cacheFile)) {
-			if((Clock.currTime() - std.file.timeLastModified(cacheFile)) < dur!"hours"(maxCacheHours)) {
-				response = std.file.readText(cacheFile);
-				goto haveResponse;
-			}
+		if(response == "false") {
+			var v1 = id[1..$];
+			ret["id"] = v1;
+			ret["name"] = v1 = "Private";
+			ret["description"] = v1 = "This is a private facebook page. Please make it public in Facebook if you want to promote it.";
+			ret["link"] = v1 = "http://facebook.com?profile.php?id=" ~ id[1..$];
+			ret["is_false"] = true;
+			return ret;
 		}
-	}

-	try {
-		response = curl(url);
-	} catch(CurlException e) {
-		throw new FacebookApiException(e.msg);
-	}
+		ret = var.fromJson(response);

-	if(useCache) {
-		std.file.write(cacheFile, response);
-	}
+		if("error" in ret) {
+			auto error = ret.error;

-    haveResponse:
-	assert(response.length);
+			if("message" in error)
+				throw new FacebookApiException(error["message"].get!string, token.length > 1 ? token : null,
+					"scope" in error ? error["scope"].get!string : null);
+			else
+				throw new FacebookApiException("couldn't get FB info");
+		}
+
+		return ret;
+	}
+}
+
+Variant[string] fbGraph(string[] info, string id, bool useCache = false, long maxCacheHours = 2) {
+	auto response = fbGraphImpl(info[1], id, useCache, maxCacheHours);

 	if(response == "false") {
 		//throw new Exception("This page is private. Please make it public in Facebook.");
@ -163,6 +145,62 @@ Variant[string] fbGraph(string[] info, string id, bool useCache = false, long ma
 	}

 	return var;
+
+}
+
+// note ids=a,b,c works too. it returns an associative array of the ids requested.
+string fbGraphImpl(string info, string id, bool useCache = false, long maxCacheHours = 2) {
+	string response;
+
+	string cacheFile;
+
+	char c = '?';
+
+	if(id.indexOf("?") != -1)
+		c = '&';
+
+	string url;
+
+	if(id[0] != '/')
+		id = "/" ~ id;
+	
+	if(info !is null)
+		url = "https://graph.facebook.com" ~ id
+			~ c ~ "access_token=" ~ info ~ "&format=json";
+	else
+		url = "http://graph.facebook.com" ~ id
+			~ c ~ "format=json";
+
+	// this makes pagination easier. the initial / is there because it is added above
+	if(id.indexOf("/http://") == 0 || id.indexOf("/https://") == 0)
+		url = id[1 ..$];
+
+	if(useCache)
+		cacheFile = "/tmp/fbGraphCache-" ~ hashToString(SHA1(url));
+
+	if(useCache) {
+		if(std.file.exists(cacheFile)) {
+			if((Clock.currTime() - std.file.timeLastModified(cacheFile)) < dur!"hours"(maxCacheHours)) {
+				response = std.file.readText(cacheFile);
+				goto haveResponse;
+			}
+		}
+	}
+	
+	try {
+		response = curl(url);
+	} catch(CurlException e) {
+		throw new FacebookApiException(e.msg);
+	}
+
+	if(useCache) {
+		std.file.write(cacheFile, response);
+	}
+
+    haveResponse:
+	assert(response.length);
+
+	return response;
 }


@ -620,7 +658,7 @@ immutable(ubyte)[] base64UrlDecode(string e) {
 	return assumeUnique(ugh);
 }

-Variant parseSignedRequest(in string req, string apisecret) {
+Ret parseSignedRequest(Ret = Variant)(in string req, string apisecret) {
 	auto parts = req.split(".");

 	immutable signature = parts[0];
@ -633,7 +671,10 @@ Variant parseSignedRequest(in string req, string apisecret) {

 	auto json = cast(string) base64UrlDecode(jsonEncoded);

-	return jsonToVariant(json);
+	static if(is(Ret == Variant))
+		return jsonToVariant(json);
+	else
+		return Ret.fromJson(json);
 }

 string stripWhitespace(string w) {
--- a/postgres.d
+++ b/postgres.d
@ -62,7 +62,10 @@ class PostgresResult : ResultSet {
 	int getFieldIndex(string field) {
 		if(mapping is null)
 			makeFieldMapping();
-		return mapping[field];
+		field = field.toLower;
+		if(field in mapping)
+			return mapping[field];
+		else throw new Exception("no mapping " ~ field);
 	}


--- a/script.d
+++ b/script.d
@ -273,6 +273,12 @@ class TokenStream(TextStream) {
 					pos++;
 				}

+				if(text[pos - 1] == '.') {
+					// This is something like "1.x", which is *not* a floating literal; it is UFCS on an int
+					sawDot = false;
+					pos --;
+				}
+
 				token.type = sawDot ? ScriptToken.Type.float_number : ScriptToken.Type.int_number;
 				token.str = text[0 .. pos];
 				advance(pos);
@ -1585,7 +1591,7 @@ Expression parseFactor(MyTokenStreamHere)(ref MyTokenStreamHere tokens) {
 				default:
 					break loop;
 			}
-		}
+		} else throw new Exception("Got " ~ peek.str ~ " when expecting symbol");
 	}

 	return e1;
@ -1605,6 +1611,11 @@ Expression parseAddend(MyTokenStreamHere)(ref MyTokenStreamHere tokens) {
 				case ",": // possible FIXME these are passed on to the next thing
 				case ";":
 					return e1;
+
+				case ".":
+					tokens.popFront();
+					e1 = new DotVarExpression(e1, parseVariableName(tokens));
+				break;
 				case "=":
 					tokens.popFront();
 					return new AssignExpression(e1, parseExpression(tokens));
--- a/sha.d
+++ b/sha.d
@ -161,7 +161,6 @@ template SHARange(T) if(isInputRange!(T)) {
 		}

 		void popFront() {
-		static int lol = 0;
 			if(state == 0) {
 				r.popFront;
 				/*
--- a/simpledisplay.d
+++ b/simpledisplay.d
@ -2386,8 +2386,10 @@ version(Windows) {
 						if(ret == 0)
 							done = true;

-						TranslateMessage(&message);
-						DispatchMessage(&message);
+			//			if(!IsDialogMessageA(message.hwnd, &message)) {
+							TranslateMessage(&message);
+							DispatchMessage(&message);
+			//			}
 					}

 					if(!done && handlePulse !is null)
@ -2398,8 +2400,10 @@ version(Windows) {
 				while((ret = GetMessage(&message, null, 0, 0)) != 0) {
 					if(ret == -1)
 						throw new Exception("GetMessage failed");
-					TranslateMessage(&message);
-					DispatchMessage(&message);
+			//		if(!IsDialogMessageA(message.hwnd, &message)) {
+						TranslateMessage(&message);
+						DispatchMessage(&message);
+			//		}

 					SleepEx(0, true); // I call this to give it a chance to do stuff like async io, which apparently never happens when you just block in GetMessage
 				}
@ -3571,6 +3575,8 @@ nothrow:

 		SHORT GetKeyState(int nVirtKey);

+		BOOL IsDialogMessageA(HWND, LPMSG);
+
 		int SetROP2(HDC, int);
 		enum R2_XORPEN = 7;
 		enum R2_COPYPEN = 13;
--- a/sslsocket.d
+++ b/sslsocket.d
@ -1,5 +1,8 @@
 public import std.socket;

+// see also:
+// http://msdn.microsoft.com/en-us/library/aa380536%28v=vs.85%29.aspx
+
 import deimos.openssl.ssl;

 static this() {
--- a/terminal.d
+++ b/terminal.d
@ -267,6 +267,8 @@ enum ConsoleOutputType {
 	linear = 0, /// do you want output to work one line at a time?
 	cellular = 1, /// or do you want access to the terminal screen as a grid of characters?
 	//truncatedCellular = 3, /// cellular, but instead of wrapping output to the next line automatically, it will truncate at the edges
+
+	minimalProcessing = 255, /// do the least possible work, skips most construction and desturction tasks. Only use if you know what you're doing here
 }

 /// Some methods will try not to send unnecessary commands to the screen. You can override their judgement using a ForceOption parameter, if present
@ -287,6 +289,12 @@ struct Terminal {
 	@disable this(this);
 	private ConsoleOutputType type;

+	version(Posix) {
+		private int fdOut;
+		private int fdIn;
+		private int[] delegate() getSizeOverride;
+	}
+
 	version(Posix) {
 		bool terminalInFamily(string[] terms...) {
 			import std.process;
@ -403,7 +411,8 @@ struct Terminal {
 			char[10] sequenceBuffer;
 			char[] sequence;
 			if(sequenceIn.length > 0 && sequenceIn[0] == '\033') {
-				assert(sequenceIn.length < sequenceBuffer.length - 1);
+				if(!(sequenceIn.length < sequenceBuffer.length - 1))
+					return null;
 				sequenceBuffer[1 .. sequenceIn.length + 1] = sequenceIn[];
 				sequenceBuffer[0] = '\\';
 				sequenceBuffer[1] = 'E';
@ -566,11 +575,25 @@ struct Terminal {
 	/**
 	 * Constructs an instance of Terminal representing the capabilities of
 	 * the current terminal.
+	 *
+	 * While it is possible to override the stdin+stdout file descriptors, remember
+	 * that is not portable across platforms and be sure you know what you're doing.
+	 *
+	 * ditto on getSizeOverride. That's there so you can do something instead of ioctl.
 	 */
-	this(ConsoleOutputType type) {
+	this(ConsoleOutputType type, int fdIn = 0, int fdOut = 1, int[] delegate() getSizeOverride = null) {
+		this.fdIn = fdIn;
+		this.fdOut = fdOut;
+		this.getSizeOverride = getSizeOverride;
+		this.type = type;
+
 		readTermcap();

-		this.type = type;
+		if(type == ConsoleOutputType.minimalProcessing) {
+			_suppressDestruction = true;
+			return;
+		}
+
 		if(type == ConsoleOutputType.cellular) {
 			doTermcap("ti");
 			moveTo(0, 0, ForceOption.alwaysSend); // we need to know where the cursor is for some features to work, and moving it is easier than querying it
@ -809,7 +832,7 @@ http://msdn.microsoft.com/en-us/library/windows/desktop/ms683193%28v=vs.85%29.as
 			ssize_t written;

 			while(writeBuffer.length) {
-				written = unix.write(1 /*this.fd*/, writeBuffer.ptr, writeBuffer.length);
+				written = unix.write(this.fdOut, writeBuffer.ptr, writeBuffer.length);
 				if(written < 0)
 					throw new Exception("write failed for some reason");
 				writeBuffer = writeBuffer[written .. $];
@ -837,9 +860,11 @@ http://msdn.microsoft.com/en-us/library/windows/desktop/ms683193%28v=vs.85%29.as

 			return [cols, rows];
 		} else {
-			winsize w;
-			ioctl(0, TIOCGWINSZ, &w);
-			return [w.ws_col, w.ws_row];
+			if(getSizeOverride is null) {
+				winsize w;
+				ioctl(0, TIOCGWINSZ, &w);
+				return [w.ws_col, w.ws_row];
+			} else return getSizeOverride();
 		}
 	}

@ -1024,7 +1049,8 @@ struct RealTimeConsoleInput {
 	@disable this(this);

 	version(Posix) {
-		private int fd;
+		private int fdOut;
+		private int fdIn;
 		private sigaction_t oldSigWinch;
 		private sigaction_t oldSigIntr;
 		private termios old;
@ -1080,10 +1106,11 @@ struct RealTimeConsoleInput {
 		}

 		version(Posix) {
-			this.fd = 0; // stdin
+			this.fdIn = terminal.fdIn;
+			this.fdOut = terminal.fdOut;

-			{
-				tcgetattr(fd, &old);
+			if(fdIn != -1) {
+				tcgetattr(fdIn, &old);
 				auto n = old;

 				auto f = ICANON;
@ -1091,11 +1118,11 @@ struct RealTimeConsoleInput {
 					f |= ECHO;

 				n.c_lflag &= ~f;
-				tcsetattr(fd, TCSANOW, &n);
+				tcsetattr(fdIn, TCSANOW, &n);
 			}

 			// some weird bug breaks this, https://github.com/robik/ConsoleD/issues/3
-			//destructor ~= { tcsetattr(fd, TCSANOW, &old); };
+			//destructor ~= { tcsetattr(fdIn, TCSANOW, &old); };

 			if(flags & ConsoleInputFlags.size) {
 				import core.sys.posix.signal;
@ -1154,14 +1181,16 @@ struct RealTimeConsoleInput {
 			version(Windows)
 				auto listenTo = inputHandle;
 			else version(Posix)
-				auto listenTo = this.fd;
+				auto listenTo = this.fdIn;
 			else static assert(0, "idk about this OS");

 			version(Posix)
 			addListener(&signalFired);

-			addFileEventListeners(listenTo, &eventListener, null, null);
-			destructor ~= { removeFileEventListeners(listenTo); };
+			if(listenTo != -1) {
+				addFileEventListeners(listenTo, &eventListener, null, null);
+				destructor ~= { removeFileEventListeners(listenTo); };
+			}
 			addOnIdle(&terminal.flush);
 			destructor ~= { removeOnIdle(&terminal.flush); };
 		}
@ -1189,7 +1218,8 @@ struct RealTimeConsoleInput {
 	~this() {
 		// the delegate thing doesn't actually work for this... for some reason
 		version(Posix)
-			tcsetattr(fd, TCSANOW, &old);
+			if(fdIn != -1)
+				tcsetattr(fdIn, TCSANOW, &old);

 		version(Posix) {
 			if(flags & ConsoleInputFlags.size) {
@ -1217,6 +1247,9 @@ struct RealTimeConsoleInput {
 				return true; // the object is ready
 			return false;
 		} else version(Posix) {
+			if(fdIn == -1)
+				return false;
+
 			timeval tv;
 			tv.tv_sec = 0;
 			tv.tv_usec = milliseconds * 1000;
@ -1224,10 +1257,10 @@ struct RealTimeConsoleInput {
 			fd_set fs;
 			FD_ZERO(&fs);

-			FD_SET(fd, &fs);
-			select(fd + 1, &fs, null, null, &tv);
+			FD_SET(fdIn, &fs);
+			select(fdIn + 1, &fs, null, null, &tv);

-			return FD_ISSET(fd, &fs);
+			return FD_ISSET(fdIn, &fs);
 		}
 	}

@ -1241,9 +1274,12 @@ struct RealTimeConsoleInput {
 	//int inputBufferPosition;
 	version(Posix)
 	int nextRaw(bool interruptable = false) {
+		if(fdIn == -1)
+			return 0;
+
 		char[1] buf;
 		try_again:
-		auto ret = read(fd, buf.ptr, buf.length);
+		auto ret = read(fdIn, buf.ptr, buf.length);
 		if(ret == 0)
 			return 0; // input closed
 		if(ret == -1) {
@ -1261,11 +1297,14 @@ struct RealTimeConsoleInput {
 		//terminal.writef("RAW READ: %d\n", buf[0]);

 		if(ret == 1)
-			return buf[0];
+			return inputPrefilter ? inputPrefilter(buf[0]) : buf[0];
 		else
 			assert(0); // read too much, should be impossible
 	}

+	version(Posix)
+		int delegate(char) inputPrefilter;
+
 	version(Posix)
 	dchar nextChar(int starting) {
 		if(starting <= 127)
@ -1375,7 +1414,7 @@ struct RealTimeConsoleInput {
 			throw new Exception("ReadConsoleInput");

 		InputEvent[] newEvents;
-		foreach(record; buffer[0 .. actuallyRead]) {
+		input_loop: foreach(record; buffer[0 .. actuallyRead]) {
 			switch(record.EventType) {
 				case KEY_EVENT:
 					auto ev = record.KeyEvent;
@ -1416,18 +1455,18 @@ struct RealTimeConsoleInput {
 							//press or release
 							e.eventType = MouseEvent.Type.Pressed;
 							static DWORD lastButtonState;
+							auto lastButtonState2 = lastButtonState;
 							e.buttons = ev.dwButtonState;
+							lastButtonState = e.buttons;

 							// this is sent on state change. if fewer buttons are pressed, it must mean released
-							if(e.buttons < lastButtonState) {
+							if(cast(DWORD) e.buttons < lastButtonState2) {
 								e.eventType = MouseEvent.Type.Released;
 								// if last was 101 and now it is 100, then button far right was released
 								// so we flip the bits, ~100 == 011, then and them: 101 & 011 == 001, the
 								// button that was released
-								e.buttons = lastButtonState & ~e.buttons;
+								e.buttons = lastButtonState2 & ~e.buttons;
 							}
-
-							lastButtonState = e.buttons;
 						break;
 						case MOUSE_MOVED:
 							e.eventType = MouseEvent.Type.Moved;
@ -1441,6 +1480,7 @@ struct RealTimeConsoleInput {
 								e.buttons = MouseEvent.Button.ScrollUp;
 						break;
 						default:
+							continue input_loop;
 					}

 					newEvents ~= InputEvent(e);
@ -1678,7 +1718,9 @@ struct RealTimeConsoleInput {

 							uint modifierState;

-							int modGot = to!int(parts[1]);
+							int modGot;
+							if(parts.length > 1)
+								modGot = to!int(parts[1]);
 							mod_switch: switch(modGot) {
 								case 2: modifierState |= ModifierState.shift; break;
 								case 3: modifierState |= ModifierState.alt; break;
@ -1758,6 +1800,8 @@ struct RealTimeConsoleInput {
 		auto c = nextRaw(true);
 		if(c == -1)
 			return null; // interrupted; give back nothing so the other level can recheck signal flags
+		if(c == 0)
+			throw new Exception("stdin has reached end of file");
 		if(c == '\033') {
 			if(timedCheckForInput(50)) {
 				// escape sequence
--- a/web.d
+++ b/web.d
@ -2,6 +2,8 @@ module arsd.web;

 // it would be nice to be able to add meta info to a returned envelope

+// with cookie sessions, you must commit your session yourself before writing any content
+
 enum RequirePost;
 enum RequireHttps;
 enum NoAutomaticForm;
@ -246,6 +248,9 @@ string linkTo(alias func, T...)(T args) {
 class WebDotDBaseType {
 	Cgi cgi; /// lower level access to the request

+	/// use this to look at exceptions and set up redirects and such. keep in mind it does NOT change the regular behavior
+	void exceptionExaminer(Throwable e) {}
+
 	/// Override this if you want to do something special to the document
 	/// You should probably call super._postProcess at some point since I
 	/// might add some default transformations here.
@ -416,6 +421,8 @@ class ApiProvider : WebDotDBaseType {
 		if(document is null)
 			return;
 		auto bod = document.mainBody;
+		if(bod is null)
+			return;
 		if(!bod.hasAttribute("data-csrf-key")) {
 			auto tokenInfo = _getCsrfInfo();
 			if(tokenInfo is null)
@ -683,7 +690,6 @@ class ApiProvider : WebDotDBaseType {
 		return _catchAll(path);
 	}

-
 	/// When in website mode, you can use this to beautify the error message
 	Document delegate(Throwable) _errorFunction;
 }
@ -1179,7 +1185,7 @@ CallInfo parseUrl(in ReflectionInfo* reflection, string url, string defaultFunct
 /// instantiation should be an object of your ApiProvider type.
 /// pathInfoStartingPoint is used to make a slice of it, incase you already consumed part of the path info before you called this.

-void run(Provider)(Cgi cgi, Provider instantiation, size_t pathInfoStartingPoint = 0, bool handleAllExceptions = true) if(is(Provider : ApiProvider)) {
+void run(Provider)(Cgi cgi, Provider instantiation, size_t pathInfoStartingPoint = 0, bool handleAllExceptions = true, Session session = null) if(is(Provider : ApiProvider)) {
 	assert(instantiation !is null);

 	instantiation.cgi = cgi;
@ -1317,6 +1323,7 @@ void run(Provider)(Cgi cgi, Provider instantiation, size_t pathInfoStartingPoint
 		secondaryFormat = cgi.request("secondaryFormat", "");
 		if(secondaryFormat.length == 0) secondaryFormat = null;

+		{ // scope so we can goto over this
 		JSONValue res;

 		// FIXME: hackalicious garbage. kill.
@ -1351,6 +1358,7 @@ void run(Provider)(Cgi cgi, Provider instantiation, size_t pathInfoStartingPoint
 				//	cgi.setResponseContentType("application/json");
 		result.success = true;
 		result.result = res;
+		}

 		do_nothing_else: {}

@ -1361,6 +1369,8 @@ void run(Provider)(Cgi cgi, Provider instantiation, size_t pathInfoStartingPoint
 		result.type = e.classinfo.name;
 		debug result.dFullString = e.toString();

+		realObject.exceptionExaminer(e);
+
 		if(envelopeFormat == "document" || envelopeFormat == "html") {
 			if(auto fve = cast(FormValidationException) e) {
 				auto thing = fve.formFunction;
@ -1464,6 +1474,10 @@ void run(Provider)(Cgi cgi, Provider instantiation, size_t pathInfoStartingPoint
 		}
 	} finally {
 		// the function must have done its own thing; we need to quit or else it will trigger an assert down here
+		version(webd_cookie_sessions) {
+			if(cgi.canOutputHeaders() && session !is null)
+				session.commit();
+		}
 		if(!cgi.isClosed())
 		switch(envelopeFormat) {
 			case "no-processing":
@ -1710,17 +1724,24 @@ mixin template CustomCgiFancyMain(CustomCgi, T, Args...) if(is(CustomCgi : Cgi))
 		version(no_automatic_session) {}
 		else {
 			auto session = new Session(cgi);
-			scope(exit) {
-				// I only commit automatically on non-bots to avoid writing too many files
-				// looking for bot should catch most them without false positives...
-				// empty user agent is prolly a tester too so i'll let that slide
-				if(cgi.userAgent.length && cgi.userAgent.toLower.indexOf("bot") == -1)
-					session.commit();
+			version(webd_cookie_sessions) { } // cookies have to be outputted before here since they are headers
+			else {
+				scope(exit) {
+					// I only commit automatically on non-bots to avoid writing too many files
+					// looking for bot should catch most them without false positives...
+					// empty user agent is prolly a tester too so i'll let that slide
+					if(cgi.userAgent.length && cgi.userAgent.toLower.indexOf("bot") == -1)
+						session.commit();
+				}
 			}
 			instantiation.session = session;
 		}

-		run(cgi, instantiation);
+		version(webd_cookie_sessions)
+			run(cgi, instantiation, 0, true, session);
+		else
+			run(cgi, instantiation);
+
 /+
 		if(args.length > 1) {
 			string[string][] namedArgs;
@ -1775,13 +1796,14 @@ Form createAutomaticForm(Document document, string action, in Parameter[] parame

 	foreach(param; parameters) {
 		Element input;
+		string type;

 		if(param.makeFormElement !is null) {
 			input = param.makeFormElement(document, param.name);
 			goto gotelement;
 		}

-		string type = param.type;
+		type = param.type;
 		if(param.name in fieldTypes)
 			type = fieldTypes[param.name];
 		
@ -2108,7 +2130,8 @@ JSONValue toJsonValue(T, R = ApiProvider)(T a, string formatToStringAs = null, R
 	JSONValue val;
 	static if(is(T == typeof(null)) || is(T == void*)) {
 		/* void* goes here too because we don't know how to make it work... */
-		val.type = JSON_TYPE.NULL;
+		val.object = null;
+		//val.type = JSON_TYPE.NULL;
 	} else static if(is(T == JSONValue)) {
 		val = a;
 	} else static if(__traits(compiles, val = a.makeJsonValue())) {
@ -2117,69 +2140,76 @@ JSONValue toJsonValue(T, R = ApiProvider)(T a, string formatToStringAs = null, R

 	// FIXME: should we special case something like struct Html?
 	} else static if(is(T : DateTime)) {
-		val.type = JSON_TYPE.STRING;
+		//val.type = JSON_TYPE.STRING;
 		val.str = a.toISOExtString();
 	} else static if(is(T : Element)) {
 		if(a is null) {
-			val.type = JSON_TYPE.NULL;
+			//val.type = JSON_TYPE.NULL;
+			val = null;
 		} else {
-			val.type = JSON_TYPE.STRING;
+			//val.type = JSON_TYPE.STRING;
 			val.str = a.toString();
 		}
 	} else static if(is(T == long)) {
 		// FIXME: let's get a better range... I think it goes up to like 1 << 50 on positive and negative
 		// but this works for now
 		if(a < int.max && a > int.min) {
-			val.type = JSON_TYPE.INTEGER;
+			//val.type = JSON_TYPE.INTEGER;
 			val.integer = to!long(a);
 		} else {
 			// WHY? because javascript can't actually store all 64 bit numbers correctly
-			val.type = JSON_TYPE.STRING;
+			//val.type = JSON_TYPE.STRING;
 			val.str = to!string(a);
 		}
 	} else static if(isIntegral!(T)) {
-		val.type = JSON_TYPE.INTEGER;
+		//val.type = JSON_TYPE.INTEGER;
 		val.integer = to!long(a);
 	} else static if(isFloatingPoint!(T)) {
-		val.type = JSON_TYPE.FLOAT;
+		//val.type = JSON_TYPE.FLOAT;
 		val.floating = to!real(a);
 	} else static if(isPointer!(T)) {
 		if(a is null) {
-			val.type = JSON_TYPE.NULL;
+			//val.type = JSON_TYPE.NULL;
+			val = null;
 		} else {
 			val = toJsonValue!(typeof(*a), R)(*a, formatToStringAs, api);
 		}
 	} else static if(is(T == bool)) {
 		if(a == true)
-			val.type = JSON_TYPE.TRUE;
+			val = true; // .type = JSON_TYPE.TRUE;
 		if(a == false)
-			val.type = JSON_TYPE.FALSE;
+			val = false; // .type = JSON_TYPE.FALSE;
 	} else static if(isSomeString!(T)) {
-		val.type = JSON_TYPE.STRING;
+		//val.type = JSON_TYPE.STRING;
 		val.str = to!string(a);
 	} else static if(isAssociativeArray!(T)) {
-		val.type = JSON_TYPE.OBJECT;
+		//val.type = JSON_TYPE.OBJECT;
+		JSONValue[string] valo;
 		foreach(k, v; a) {
-			val.object[to!string(k)] = toJsonValue!(typeof(v), R)(v, formatToStringAs, api);
+			valo[to!string(k)] = toJsonValue!(typeof(v), R)(v, formatToStringAs, api);
 		}
+		val = valo;
 	} else static if(isArray!(T)) {
-		val.type = JSON_TYPE.ARRAY;
+		//val.type = JSON_TYPE.ARRAY;
 		val.array.length = a.length;
 		foreach(i, v; a) {
 			val.array[i] = toJsonValue!(typeof(v), R)(v, formatToStringAs, api);
 		}
 	} else static if(is(T == struct)) { // also can do all members of a struct...
-		val.type = JSON_TYPE.OBJECT;
+		//val.type = JSON_TYPE.OBJECT;
+
+		JSONValue[string] valo;

 		foreach(i, member; a.tupleof) {
 			string name = a.tupleof[i].stringof[2..$];
 			static if(a.tupleof[i].stringof[2] != '_')
-				val.object[name] = toJsonValue!(typeof(member), R)(member, formatToStringAs, api);
+				valo[name] = toJsonValue!(typeof(member), R)(member, formatToStringAs, api);
 		}
 			// HACK: bug in dmd can give debug members in a non-debug build
 			//static if(__traits(compiles, __traits(getMember, a, member)))
+		val = valo;
 	} else { /* our catch all is to just do strings */
-		val.type = JSON_TYPE.STRING;
+		//val.type = JSON_TYPE.STRING;
 		val.str = to!string(a);
 		// FIXME: handle enums
 	}
@ -2188,7 +2218,8 @@ JSONValue toJsonValue(T, R = ApiProvider)(T a, string formatToStringAs = null, R
 	// don't want json because it could recurse
 	if(val.type == JSON_TYPE.OBJECT && formatToStringAs !is null && formatToStringAs != "json") {
 		JSONValue formatted;
-		formatted.type = JSON_TYPE.STRING;
+		//formatted.type = JSON_TYPE.STRING;
+		formatted.str = "";

 		formatAs!(T, R)(a, formatToStringAs, api, &formatted, null /* only doing one level of special formatting */);
 		assert(formatted.type == JSON_TYPE.STRING);
@ -2338,7 +2369,7 @@ class ParamCheckHelper {
 				// FIXME: fix D's AA
 				foreach(k, v; among)
 					if(k == name) {
-						value = fromUrlParam!T(v);
+						value = fromUrlParam!T(v, name, null);
 						break;
 					}
 			//}
@ -2393,7 +2424,7 @@ auto check(alias field)(ParamCheckHelper helper, bool delegate(typeof(field)) ok

 bool isConvertableTo(T)(string v) {
 	try {
-		auto t = fromUrlParam!(T)(v);
+		auto t = fromUrlParam!(T)(v, null, null);
 		return true;
 	} catch(Exception e) {
 		return false;
@ -2473,7 +2504,7 @@ class NoSuchFunctionException : NoSuchPageException {
 	}
 }

-type fromUrlParam(type)(string ofInterest) {
+type fromUrlParam(type)(in string ofInterest, in string name, in string[][string] all) {
 	type ret;

 	static if(isArray!(type) && !isSomeString!(type)) {
@ -2488,12 +2519,22 @@ type fromUrlParam(type)(string ofInterest) {
 		ret = doc.root;
 	} else static if(is(type : Text)) {
 		ret = ofInterest;
+	} else static if(is(type : Html)) {
+		ret.source = ofInterest;
 	} else static if(is(type : TimeOfDay)) {
 		ret = TimeOfDay.fromISOExtString(ofInterest);
 	} else static if(is(type : Date)) {
 		ret = Date.fromISOExtString(ofInterest);
 	} else static if(is(type : DateTime)) {
 		ret = DateTime.fromISOExtString(ofInterest);
+	} else static if(is(type == struct)) {
+		auto n = name.length ? (name ~ ".")  : "";
+		foreach(idx, thing; ret.tupleof) {
+			enum fn = ret.tupleof[idx].stringof[4..$];
+			auto lol = n ~ fn;
+			if(lol in all)
+				ret.tupleof[idx] = fromUrlParam!(typeof(thing))(all[lol], lol, all);
+		}
 	}
 	/*
 	else static if(is(type : struct)) {
@ -2509,20 +2550,20 @@ type fromUrlParam(type)(string ofInterest) {
 }

 /// turns a string array from the URL into a proper D type
-type fromUrlParam(type)(string[] ofInterest) {
+type fromUrlParam(type)(in string[] ofInterest, in string name, in string[][string] all) {
 	type ret;

 	// Arrays in a query string are sent as the name repeating...
 	static if(isArray!(type) && !isSomeString!type) {
 		foreach(a; ofInterest) {
-			ret ~= fromUrlParam!(ElementType!(type))(a);
+			ret ~= fromUrlParam!(ElementType!(type))(a, name, all);
 		}
 	} else static if(isArray!(type) && isSomeString!(ElementType!type)) {
 		foreach(a; ofInterest) {
-			ret ~= fromUrlParam!(ElementType!(type))(a);
+			ret ~= fromUrlParam!(ElementType!(type))(a, name, all);
 		}
 	} else
-		ret = fromUrlParam!type(ofInterest[$-1]);
+		ret = fromUrlParam!type(ofInterest[$-1], name, all);

 	return ret;
 }
@ -2541,7 +2582,8 @@ WrapperFunction generateWrapper(alias ObjectType, string funName, alias f, R)(Re
 	WrapperReturn wrapper(Cgi cgi, WebDotDBaseType object, in string[][string] sargs, in string format, in string secondaryFormat = null) {

 		JSONValue returnValue;
-		returnValue.type = JSON_TYPE.STRING;
+		returnValue.str = "";
+		//returnValue.type = JSON_TYPE.STRING;

 		auto instantiation = getMemberDelegate!(ObjectType, funName)(cast(ObjectType) object);

@ -2597,6 +2639,9 @@ WrapperFunction generateWrapper(alias ObjectType, string funName, alias f, R)(Re
 					} else 	static if(parameterHasDefault!(f)(i)) {
 						//args[i] = mixin(parameterDefaultOf!(f)(i));
 						args[i] = cast(type) parameterDefaultOf!(f, i);
+					} else 	static if(is(type == struct)) {
+						// try to load a struct as obj.members
+						args[i] = fromUrlParam!type(cast(string) null, name, sargs);
 					} else {
 						throw new InsufficientParametersException(funName, "arg " ~ name ~ " is not present");
 					}
@ -2634,7 +2679,7 @@ WrapperFunction generateWrapper(alias ObjectType, string funName, alias f, R)(Re
 					}


-					args[i] = fromUrlParam!type(ofInterest);
+					args[i] = fromUrlParam!type(ofInterest, using, sargs);
 				}
 			}
 		}
@ -2919,8 +2964,11 @@ class Session {
 		return new Session(cgi, cookieParams, useFile, true);
 	}

-	version(webd_memory_sessions)
+	version(webd_memory_sessions) {
+		// FIXME: make this a full fledged option, maybe even with an additional
+		// process to hold the information
 		__gshared static string[string][string] sessions;
+	}

 	/// Loads the session if available, and creates one if not.
 	/// May write a session id cookie to the passed cgi object.
@ -2938,9 +2986,9 @@ class Session {

 		bool isNew = false;
 		// string token; // using a member, see the note below
-		if(cookieParams.name in cgi.cookies && cgi.cookies[cookieParams.name].length)
+		if(cookieParams.name in cgi.cookies && cgi.cookies[cookieParams.name].length) {
 			token = cgi.cookies[cookieParams.name];
-		else {
+		} else {
 			if("x-arsd-session-override" in cgi.requestHeaders) {
 				loadSpecialSession(cgi);
 				return;
@ -2993,7 +3041,9 @@ class Session {
 		// Note: this won't work with memory sessions
 		version(webd_memory_sessions)
 			throw new Exception("You cannot access sessions this way.");
-		else {
+		else version(webd_cookie_sessions) {
+			// FIXME: implement
+		} else {
 			version(no_session_override)
 				throw new Exception("You cannot access sessions this way.");
 			else {
@ -3025,6 +3075,8 @@ class Session {
 	public static void garbageCollect(bool delegate(string[string] data) finalizer = null, Duration maxAge = dur!"hours"(4)) {
 		version(webd_memory_sessions)
 			return; // blargh. FIXME really, they should be null so the gc can free them
+		version(webd_cookie_sessions)
+			return; // nothing needed to be done here

 		auto ctime = Clock.currTime();
 		foreach(DirEntry e; dirEntries(getTempDirectory(), "arsd_session_file_*", SpanMode.shallow)) {
@ -3054,7 +3106,9 @@ class Session {
 	}

 	private string makeSessionId(string cookieToken) {
-		_sessionId = hashToString(SHA256(cgi.remoteAddress ~ "\r\n" ~ cgi.userAgent ~ "\r\n" ~ cookieToken));
+		// the remote address changes too much on some ISPs to be a useful check;
+		// using it means sessions get lost regularly and users log out :(
+		_sessionId = hashToString(SHA256(/*cgi.remoteAddress ~ "\r\n" ~*/ cgi.userAgent ~ "\r\n" ~ cookieToken));
 		return _sessionId;
 	}

@ -3074,7 +3128,9 @@ class Session {
 		auto tmp = uniform(0, ulong.max);
 		auto token = to!string(tmp);

-		setOurCookie(token);
+		version(webd_cookie_sessions) {}
+		else
+			setOurCookie(token);

 		return token;
 	}
@ -3111,6 +3167,8 @@ class Session {
 				if(sessionId in sessions)
 					sessions.remove(sessionId);
 			}
+		} else version(webd_cookie_sessions) {
+			// intentionally blank; the cookie will replace the old one
 		} else {
 			if(std.file.exists(getFilePath()))
 				std.file.remove(getFilePath());
@ -3138,6 +3196,8 @@ class Session {
 				if(sessionId in sessions)
 					sessions.remove(sessionId);
 			}
+		} else version(webd_cookie_sessions) {
+			// nothing needed, setting data to null will do the trick
 		} else {
 			if(std.file.exists(getFilePath()))
 				std.file.remove(getFilePath());
@ -3223,9 +3283,12 @@ class Session {
 	}

 	private static string[string] loadData(string path) {
-		string[string] data = null;
 		auto json = std.file.readText(path);
+		return loadDataFromJson(json);
+	}

+	private static string[string] loadDataFromJson(string json) {
+		string[string] data = null;
 		auto obj = parseJSON(json);
 		enforce(obj.type == JSON_TYPE.OBJECT);
 		foreach(k, v; obj.object) {
@ -3272,7 +3335,6 @@ class Session {
 	void reload() {
 		data = null;

-
 		version(webd_memory_sessions) {
 			synchronized {
 				if(auto s = sessionId in sessions) {
@ -3283,6 +3345,27 @@ class Session {
 					_hasData = false;
 				}
 			}
+		} else version(webd_cookie_sessions) {
+			// FIXME
+			if(cookieParams.name in cgi.cookies) {
+				auto cookie = cgi.cookies[cookieParams.name];
+				if(cookie.length) {
+					import std.base64;
+					import std.zlib;
+
+					auto cd = Base64URL.decode(cookie);
+
+					if(cd[0] == 'Z')
+						cd = cast(ubyte[]) uncompress(cd[1 .. $]);
+
+					if(cd.length > 20) {
+						auto hash = cd[$ - 20 .. $];
+						auto json = cast(string) cd[0 .. $-20];
+
+						data = loadDataFromJson(json);
+					}
+				}
+			}
 		} else {
 			auto path = getFilePath();
 			try {
@ -3298,6 +3381,12 @@ class Session {
 		}
 	}

+	version(webd_cookie_sessions)
+	private ubyte[20] getSignature(string jsonData) {
+		import arsd.hmac;
+		return hmac!SHA1(import("webd-cookie-signature-key.txt"), jsonData)[0 .. 20];
+	}
+
 	// FIXME: there's a race condition here - if the user is using the session
 	// from two windows, one might write to it as we're executing, and we won't
 	// see the difference.... meaning we'll write the old data back.
@ -3307,13 +3396,31 @@ class Session {
 		if(_readOnly)
 			return;
 		if(force || changed) {
-
-
 			version(webd_memory_sessions) {
 				synchronized {
 					sessions[sessionId] = data;
 					changed = false;
 				}
+			} else version(webd_cookie_sessions) {
+				immutable(ubyte)[] dataForCookie;
+				auto jsonData = toJson(data);
+				auto hash = getSignature(jsonData);
+				if(jsonData.length > 64) {
+					import std.zlib;
+					// file format: JSON ~ hash[20]
+					auto compressor = new Compress();
+					dataForCookie ~= "Z";
+					dataForCookie ~= cast(ubyte[]) compressor.compress(toJson(data));
+					dataForCookie ~= cast(ubyte[]) compressor.compress(hash);
+					dataForCookie ~= cast(ubyte[]) compressor.flush();
+				} else {
+					dataForCookie = cast(immutable(ubyte)[]) jsonData;
+					dataForCookie ~= hash;
+				}
+
+				import std.base64;
+				setOurCookie(Base64URL.encode(dataForCookie));
+				changed = false;
 			} else {
 				std.file.write(getFilePath(), toJson(data));
 				changed = false;
@ -3330,7 +3437,7 @@ class Session {
 		}
 	}

-	private string[string] data;
+	string[string] data;
 	private bool _hasData;
 	private bool changed;
 	private bool _readOnly;
@ -3403,8 +3510,13 @@ struct TemplateFilters {
 	string date(string replacement, string[], in Element, string) {
 		if(replacement.length == 0)
 			return replacement;
-		auto dateTicks = to!long(replacement);
-		auto date = SysTime( unixTimeToStdTime(cast(time_t)(dateTicks/1_000)) );
+		SysTime date;
+		if(replacement.isNumeric) {
+			auto dateTicks = to!long(replacement);
+			date = SysTime( unixTimeToStdTime(cast(time_t)(dateTicks/1_000)) );
+		} else {
+			date = cast(SysTime) DateTime.fromISOExtString(replacement);
+		}
 		
 		auto day = date.day;
 		auto year = date.year;
@ -3415,6 +3527,21 @@ struct TemplateFilters {
 		return replacement;
 	}

+	string limitSize(string replacement, string[] args, in Element, string) {
+		auto limit = to!int(args[0]);
+
+		if(replacement.length > limit) {
+			replacement = replacement[0 .. limit];
+			while(replacement.length && replacement[$-1] > 127)
+				replacement = replacement[0 .. $-1];
+
+			if(args.length > 1)
+				replacement ~= args[1];
+		}
+
+		return replacement;
+	}
+
 	string uri(string replacement, string[], in Element, string) {
 		return std.uri.encodeComponent(replacement);
 	}
@ -3546,6 +3673,11 @@ void applyTemplateToElement(
 			// text nodes have no attributes, but they do have text we might replace.
 			tc.contents = htmlTemplateWithData(tc.contents, vars, pipeFunctions, false, tc, null);
 		} else {
+			if(ele.hasAttribute("data-html-from")) {
+				ele.innerHTML = htmlTemplateWithData(ele.dataset.htmlFrom, vars, pipeFunctions, false, ele, null);
+				ele.removeAttribute("data-html-from");
+			}
+
 			auto rs = cast(RawSource) ele;
 			if(rs !is null) {
 				bool isSpecial;
@ -4728,7 +4860,7 @@ enum string javascriptBaseImpl = q{


 template hasAnnotation(alias f, Attr) {
-	bool helper() {
+	static bool helper() {
 		foreach(attr; __traits(getAttributes, f))
 			static if(is(attr == Attr) || is(typeof(attr) == Attr))
 				return true;
@ -4739,7 +4871,7 @@ template hasAnnotation(alias f, Attr) {
 }

 template hasValueAnnotation(alias f, Attr) {
-	bool helper() {
+	static bool helper() {
 		foreach(attr; __traits(getAttributes, f))
 			static if(is(typeof(attr) == Attr))
 				return true;
@ -4752,7 +4884,7 @@ template hasValueAnnotation(alias f, Attr) {


 template getAnnotation(alias f, Attr) if(hasValueAnnotation!(f, Attr)) {
-	auto helper() {
+	static auto helper() {
 		foreach(attr; __traits(getAttributes, f))
 			static if(is(typeof(attr) == Attr))
 				return attr;