// Written in the D programming language.

/**
 * 
 * Tom's Obvious, Minimal Language (v0.4.0).
 *
 * License: $(HTTP https://github.com/Kripth/toml/blob/master/LICENSE, MIT)
 * Authors: Kripth
 * References: $(LINK https://github.com/toml-lang/toml/blob/master/README.md)
 * Source: $(HTTP https://github.com/Kripth/toml/blob/master/src/toml/toml.d, toml/_toml.d)
 * 
 */
module toml.toml;

import std.algorithm : canFind, min, stripRight;
import std.array : Appender;
import std.ascii : newline;
import std.conv : to;
import std.datetime : SysTime, DateTimeD = DateTime, Date,
	TimeOfDayD = TimeOfDay;
import std.exception : enforce, assertThrown;
import std.math : isNaN, isFinite;
import std..string : join, strip, replace, indexOf;
import std.traits : isNumeric, isIntegral, isFloatingPoint, isArray,
	isAssociativeArray, KeyType;
import std.typecons : Tuple;
import std.utf : encode, UseReplacementDchar;

import toml.datetime : DateTime, TimeOfDay;

/**
 * Flags that control how a TOML document is parsed and encoded.
 */
enum TOMLOptions
{

	none = 0x00,
	unquotedStrings = 0x01, /// allow unquoted strings as values when parsing

}

/**
 * TOML type enumeration.
 */
enum TOML_TYPE : byte
{

	STRING, /// Indicates the type of a TOMLValue.
	INTEGER, /// ditto
	FLOAT, /// ditto
	OFFSET_DATETIME, /// ditto
	LOCAL_DATETIME, /// ditto
	LOCAL_DATE, /// ditto
	LOCAL_TIME, /// ditto
	ARRAY, /// ditto
	TABLE, /// ditto
	TRUE, /// ditto
	FALSE /// ditto

}

/**
 * Main table of a TOML document.
 * It works as a TOMLValue with the TOML_TYPE.TABLE type.
 */
struct TOMLDocument
{

	public TOMLValue[string] table;

	public this(TOMLValue[string] table)
	{
		this.table = table;
	}

	public this(TOMLValue value)
	{
		this(value.table);
	}

	public string toString()
	{
		Appender!string appender;
		foreach (key, value; this.table)
		{
			appender.put(formatKey(key));
			appender.put(" = ");
			value.append(appender);
			appender.put(newline);
		}
		return appender.data;
	}

	alias table this;

}

/**
 * Value of a TOML value.
 */
struct TOMLValue
{

	private union Store
	{
		string str;
		long integer;
		double floating;
		SysTime offsetDatetime;
		DateTime localDatetime;
		Date localDate;
		TimeOfDay localTime;
		TOMLValue[] array;
		TOMLValue[string] table;
	}

	private Store store;
	private TOML_TYPE _type;

	public this(T)(T value)
	{
		static if (is(T == TOML_TYPE))
		{
			this._type = value;
		}
		else
		{
			this.assign(value);
		}
	}

	public inout pure nothrow @property @safe @nogc TOML_TYPE type()
	{
		return this._type;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.STRING
	 */
	public inout @property @trusted string str()
	{
		enforce!TOMLException(this._type == TOML_TYPE.STRING, "TOMLValue is not a string");
		return this.store.str;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.INTEGER
	 */
	public inout @property @trusted long integer()
	{
		enforce!TOMLException(this._type == TOML_TYPE.INTEGER, "TOMLValue is not an integer");
		return this.store.integer;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.FLOAT
	 */
	public inout @property @trusted double floating()
	{
		enforce!TOMLException(this._type == TOML_TYPE.FLOAT, "TOMLValue is not a float");
		return this.store.floating;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.OFFSET_DATETIME
	 */
	public @property ref SysTime offsetDatetime() return
	{
		enforce!TOMLException(this.type == TOML_TYPE.OFFSET_DATETIME,
				"TOMLValue is not an offset datetime");
		return this.store.offsetDatetime;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.LOCAL_DATETIME
	 */
	public @property @trusted ref DateTime localDatetime() return
	{
		enforce!TOMLException(this._type == TOML_TYPE.LOCAL_DATETIME,
				"TOMLValue is not a local datetime");
		return this.store.localDatetime;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.LOCAL_DATE
	 */
	public @property @trusted ref Date localDate() return
	{
		enforce!TOMLException(this._type == TOML_TYPE.LOCAL_DATE, "TOMLValue is not a local date");
		return this.store.localDate;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.LOCAL_TIME
	 */
	public @property @trusted ref TimeOfDay localTime() return
	{
		enforce!TOMLException(this._type == TOML_TYPE.LOCAL_TIME, "TOMLValue is not a local time");
		return this.store.localTime;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.ARRAY
	 */
	public @property @trusted ref TOMLValue[] array() return
	{
		enforce!TOMLException(this._type == TOML_TYPE.ARRAY, "TOMLValue is not an array");
		return this.store.array;
	}

	/**
	 * Throws: TOMLException if type is not TOML_TYPE.TABLE
	 */
	public @property @trusted ref TOMLValue[string] table() return
	{
		enforce!TOMLException(this._type == TOML_TYPE.TABLE, "TOMLValue is not a table");
		return this.store.table;
	}

	public TOMLValue opIndex(size_t index)
	{
		return this.array[index];
	}

	public TOMLValue* opBinaryRight(string op : "in")(string key)
	{
		return key in this.table;
	}

	public TOMLValue opIndex(string key)
	{
		return this.table[key];
	}

	public int opApply(scope int delegate(string, ref TOMLValue) dg)
	{
		enforce!TOMLException(this._type == TOML_TYPE.TABLE, "TOMLValue is not a table");
		int result;
		foreach (string key, ref value; this.store.table)
		{
			result = dg(key, value);
			if (result)
				break;
		}
		return result;
	}

	public void opAssign(T)(T value)
	{
		this.assign(value);
	}

	private void assign(T)(T value)
	{
		static if (is(T == TOMLValue))
		{
			this.store = value.store;
			this._type = value._type;
		}
		else static if (is(T : string))
		{
			this.store.str = value;
			this._type = TOML_TYPE.STRING;
		}
		else static if (isIntegral!T)
		{
			this.store.integer = value;
			this._type = TOML_TYPE.INTEGER;
		}
		else static if (isFloatingPoint!T)
		{
			this.store.floating = value.to!double;
			this._type = TOML_TYPE.FLOAT;
		}
		else static if (is(T == SysTime))
		{
			this.store.offsetDatetime = value;
			this._type = TOML_TYPE.OFFSET_DATETIME;
		}
		else static if (is(T == DateTime))
		{
			this.store.localDatetime = value;
			this._type = TOML_TYPE.LOCAL_DATETIME;
		}
		else static if (is(T == DateTimeD))
		{
			this.store.localDatetime = DateTime(value.date, TimeOfDay(value.timeOfDay));
			this._type = TOML_TYPE.LOCAL_DATETIME;
		}
		else static if (is(T == Date))
		{
			this.store.localDate = value;
			this._type = TOML_TYPE.LOCAL_DATE;
		}
		else static if (is(T == TimeOfDay))
		{
			this.store.localTime = value;
			this._type = TOML_TYPE.LOCAL_TIME;
		}
		else static if (is(T == TimeOfDayD))
		{
			this.store.localTime = TimeOfDay(value);
			this._type = TOML_TYPE.LOCAL_TIME;
		}
		else static if (isArray!T)
		{
			static if (is(T == TOMLValue[]))
			{
				if (value.length)
				{
					// verify that every element has the same type
					TOML_TYPE cmp = value[0].type;
					foreach (element; value[1 .. $])
					{
						enforce!TOMLException(element.type == cmp,
								"Array's values must be of the same type");
					}
				}
				alias data = value;
			}
			else
			{
				TOMLValue[] data;
				foreach (element; value)
				{
					data ~= TOMLValue(element);
				}
			}
			this.store.array = data;
			this._type = TOML_TYPE.ARRAY;
		}
		else static if (isAssociativeArray!T && is(KeyType!T : string))
		{
			static if (is(T == TOMLValue[string]))
			{
				alias data = value;
			}
			else
			{
				TOMLValue[string] data;
				foreach (key, v; value)
				{
					data[key] = v;
				}
			}
			this.store.table = data;
			this._type = TOML_TYPE.TABLE;
		}
		else static if (is(T == bool))
		{
			_type = value ? TOML_TYPE.TRUE : TOML_TYPE.FALSE;
		}
		else
		{
			static assert(0);
		}
	}

	public bool opEquals(T)(T value)
	{
		static if (is(T == TOMLValue))
		{
			if (this._type != value._type)
				return false;
			final switch (this.type) with (TOML_TYPE)
			{
			case STRING:
				return this.store.str == value.store.str;
			case INTEGER:
				return this.store.integer == value.store.integer;
			case FLOAT:
				return this.store.floating == value.store.floating;
			case OFFSET_DATETIME:
				return this.store.offsetDatetime == value.store.offsetDatetime;
			case LOCAL_DATETIME:
				return this.store.localDatetime == value.store.localDatetime;
			case LOCAL_DATE:
				return this.store.localDate == value.store.localDate;
			case LOCAL_TIME:
				return this.store.localTime == value.store.localTime;
			case ARRAY:
				return this.store.array == value.store.array;
				//case TABLE: return this.store.table == value.store.table; // causes errors
			case TABLE:
				return this.opEquals(value.store.table);
			case TRUE:
			case FALSE:
				return true;
			}
		}
		else static if (is(T : string))
		{
			return this._type == TOML_TYPE.STRING && this.store.str == value;
		}
		else static if (isNumeric!T)
		{
			if (this._type == TOML_TYPE.INTEGER)
				return this.store.integer == value;
			else if (this._type == TOML_TYPE.FLOAT)
				return this.store.floating == value;
			else
				return false;
		}
		else static if (is(T == SysTime))
		{
			return this._type == TOML_TYPE.OFFSET_DATETIME && this.store.offsetDatetime == value;
		}
		else static if (is(T == DateTime))
		{
			return this._type == TOML_TYPE.LOCAL_DATETIME && this.store.localDatetime.dateTime == value.dateTime
				&& this.store.localDatetime.timeOfDay.fracSecs == value.timeOfDay.fracSecs;
		}
		else static if (is(T == DateTimeD))
		{
			return this._type == TOML_TYPE.LOCAL_DATETIME
				&& this.store.localDatetime.dateTime == value;
		}
		else static if (is(T == Date))
		{
			return this._type == TOML_TYPE.LOCAL_DATE && this.store.localDate == value;
		}
		else static if (is(T == TimeOfDay))
		{
			return this._type == TOML_TYPE.LOCAL_TIME && this.store.localTime.timeOfDay == value.timeOfDay
				&& this.store.localTime.fracSecs == value.fracSecs;
		}
		else static if (is(T == TimeOfDayD))
		{
			return this._type == TOML_TYPE.LOCAL_TIME && this.store.localTime == value;
		}
		else static if (isArray!T)
		{
			if (this._type != TOML_TYPE.ARRAY || this.store.array.length != value.length)
				return false;
			foreach (i, element; this.store.array)
			{
				if (element != value[i])
					return false;
			}
			return true;
		}
		else static if (isAssociativeArray!T && is(KeyType!T : string))
		{
			if (this._type != TOML_TYPE.TABLE || this.store.table.length != value.length)
				return false;
			foreach (key, v; this.store.table)
			{
				auto cmp = key in value;
				if (cmp is null || v != *cmp)
					return false;
			}
			return true;
		}
		else static if (is(T == bool))
		{
			return value ? _type == TOML_TYPE.TRUE : _type == TOML_TYPE.FALSE;
		}
		else
		{
			return false;
		}
	}

	public void append(ref Appender!string appender)
	{
		final switch (this._type) with (TOML_TYPE)
		{
		case STRING:
			appender.put(formatString(this.store.str));
			break;
		case INTEGER:
			appender.put(this.store.integer.to!string);
			break;
		case FLOAT:
			immutable str = this.store.floating.to!string;
			appender.put(str);
			if (!str.canFind('.') && !str.canFind('e'))
				appender.put(".0");
			break;
		case OFFSET_DATETIME:
			appender.put(this.store.offsetDatetime.toISOExtString());
			break;
		case LOCAL_DATETIME:
			appender.put(this.store.localDatetime.toISOExtString());
			break;
		case LOCAL_DATE:
			appender.put(this.store.localDate.toISOExtString());
			break;
		case LOCAL_TIME:
			appender.put(this.store.localTime.toISOExtString());
			break;
		case ARRAY:
			appender.put("[");
			foreach (i, value; this.store.array)
			{
				value.append(appender);
				if (i + 1 < this.store.array.length)
					appender.put(", ");
			}
			appender.put("]");
			break;
		case TABLE:
			// display as an inline table
			appender.put("{ ");
			size_t i = 0;
			foreach (key, value; this.store.table)
			{
				appender.put(formatKey(key));
				appender.put(" = ");
				value.append(appender);
				if (++i != this.store.table.length)
					appender.put(", ");
			}
			appender.put(" }");
			break;
		case TRUE:
			appender.put("true");
			break;
		case FALSE:
			appender.put("false");
			break;
		}
	}

	public string toString()
	{
		Appender!string appender;
		this.append(appender);
		return appender.data;
	}

}

private string formatKey(string str)
{
	foreach (c; str)
	{
		if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z')
				&& c != '-' && c != '_')
			return formatString(str);
	}
	return str;
}

private string formatString(string str)
{
	Appender!string appender;
	foreach (c; str)
	{
		switch (c)
		{
		case '"':
			appender.put("\\\"");
			break;
		case '\\':
			appender.put("\\\\");
			break;
		case '\b':
			appender.put("\\b");
			break;
		case '\f':
			appender.put("\\f");
			break;
		case '\n':
			appender.put("\\n");
			break;
		case '\r':
			appender.put("\\r");
			break;
		case '\t':
			appender.put("\\t");
			break;
		default:
			appender.put(c);
		}
	}
	return "\"" ~ appender.data ~ "\"";
}

/**
 * Parses a TOML document.
 * Returns: a TOMLDocument with the parsed data
 * Throws:
 * 		TOMLParserException when the document's syntax is incorrect
 */
TOMLDocument parseTOML(string data, TOMLOptions options = TOMLOptions.none)
{

	size_t index = 0;

	/**
	 * Throws a TOMLParserException at the current line and column.
	 */
	void error(string message)
	{
		if (index >= data.length)
			index = data.length;
		size_t i, line, column;
		while (i < index)
		{
			if (data[i++] == '\n')
			{
				line++;
				column = 0;
			}
			else
			{
				column++;
			}
		}
		throw new TOMLParserException(message, line + 1, column);
	}

	/**
	 * Throws a TOMLParserException throught the error function if
	 * cond is false.
	 */
	void enforceParser(bool cond, lazy string message)
	{
		if (!cond)
		{
			error(message);
		}
	}

	TOMLValue[string] _ret;
	auto current = &_ret;

	string[][] tableNames;

	void setImpl(TOMLValue[string]* table, string[] keys, string[] original, TOMLValue value)
	{
		auto ptr = keys[0] in *table;
		if (keys.length == 1)
		{
			// should not be there
			enforceParser(ptr is null, "Key is already defined");
			(*table)[keys[0]] = value;
		}
		else
		{
			// must be a table
			if (ptr !is null)
				enforceParser((*ptr).type == TOML_TYPE.TABLE, join(original[0 .. $ - keys.length],
						".") ~ " is already defined and is not a table");
			else
				(*table)[keys[0]] = (TOMLValue[string]).init;
			setImpl(&((*table)[keys[0]].table()), keys[1 .. $], original, value);
		}
	}

	void set(string[] keys, TOMLValue value)
	{
		setImpl(current, keys, keys, value);
	}

	/**
	 * Removes whitespace characters and comments.
	 * Return: whether there's still data to read
	 */
	bool clear(bool clear_newline = true)()
	{
		static if (clear_newline)
		{
			enum chars = " \t\r\n";
		}
		else
		{
			enum chars = " \t\r";
		}
		if (index < data.length)
		{
			if (chars.canFind(data[index]))
			{
				index++;
				return clear!clear_newline();
			}
			else if (data[index] == '#')
			{
				// skip until end of line
				while (++index < data.length && data[index] != '\n')
				{
				}
				static if (clear_newline)
				{
					index++; // point at the next character
					return clear();
				}
				else
				{
					return true;
				}
			}
			else
			{
				return true;
			}
		}
		else
		{
			return false;
		}
	}

	/**
	 * Indicates whether the given character is valid in an unquoted key.
	 */
	bool isValidKeyChar(immutable char c)
	{
		return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0'
			&& c <= '9' || c == '-' || c == '_';
	}

	string readQuotedString(bool multiline)()
	{
		Appender!string ret;
		bool backslash = false;
		while (index < data.length)
		{
			static if (!multiline)
			{
				enforceParser(data[index] != '\n', "Unterminated quoted string");
			}
			if (backslash)
			{
				void readUnicode(size_t size)()
				{
					enforceParser(index + size < data.length, "Invalid UTF-8 sequence");
					char[4] buffer;
					immutable len = encode!(UseReplacementDchar.yes)(buffer,
							cast(dchar) to!ulong(data[index + 1 .. index + 1 + size], 16));
					ret.put(buffer[0 .. len].idup);
					index += size;
				}

				switch (data[index])
				{
				case '"':
					ret.put('"');
					break;
				case '\\':
					ret.put('\\');
					break;
				case 'b':
					ret.put('\b');
					break;
				case 't':
					ret.put('\t');
					break;
				case 'n':
					ret.put('\n');
					break;
				case 'f':
					ret.put('\f');
					break;
				case 'r':
					ret.put('\r');
					break;
				case 'u':
					readUnicode!4();
					break;
				case 'U':
					readUnicode!8();
					break;
				default:
					static if (multiline)
					{
						index++;
						if (clear())
						{
							// remove whitespace characters until next valid character
							index--;
							break;
						}
					}
					enforceParser(false, "Invalid escape sequence: '\\" ~ (index < data.length
							? [data[index]] : "EOF") ~ "'");
				}
				backslash = false;
			}
			else
			{
				if (data[index] == '\\')
				{
					backslash = true;
				}
				else if (data[index] == '"')
				{
					// string closed
					index++;
					static if (multiline)
					{
						// control that the string is really closed
						if (index + 2 <= data.length && data[index .. index + 2] == "\"\"")
						{
							index += 2;
							return ret.data.stripFirstLine;
						}
						else
						{
							ret.put("\"");
							continue;
						}
					}
					else
					{
						return ret.data;
					}
				}
				else
				{
					static if (multiline)
					{
						mixin(doLineConversion);
					}
					ret.put(data[index]);
				}
			}
			index++;
		}
		error("Expecting \" (double quote) but found EOF");
		assert(0);
	}

	string readSimpleQuotedString(bool multiline)()
	{
		Appender!string ret;
		while (index < data.length)
		{
			static if (!multiline)
			{
				enforceParser(data[index] != '\n', "Unterminated quoted string");
			}
			if (data[index] == '\'')
			{
				// closed
				index++;
				static if (multiline)
				{
					// there must be 3 of them
					if (index + 2 <= data.length && data[index .. index + 2] == "''")
					{
						index += 2;
						return ret.data.stripFirstLine;
					}
					else
					{
						ret.put("'");
					}
				}
				else
				{
					return ret.data;
				}
			}
			else
			{
				static if (multiline)
				{
					mixin(doLineConversion);
				}
				ret.put(data[index++]);
			}
		}
		error("Expecting ' (single quote) but found EOF");
		assert(0);
	}

	string removeUnderscores(string str, string[] ranges...)
	{
		bool checkRange(char c)
		{
			foreach (range; ranges)
			{
				if (c >= range[0] && c <= range[1])
					return true;
			}
			return false;
		}

		bool underscore = false;
		for (size_t i = 0; i < str.length; i++)
		{
			if (str[i] == '_')
			{
				if (underscore || i == 0 || i == str.length - 1
						|| !checkRange(str[i - 1]) || !checkRange(str[i + 1]))
					throw new Exception("");
				str = str[0 .. i] ~ str[i + 1 .. $];
				i--;
				underscore = true;
			}
			else
			{
				underscore = false;
			}
		}
		return str;
	}

	TOMLValue readSpecial()
	{
		immutable start = index;
		while (index < data.length && !"\t\r\n,]}#".canFind(data[index]))
			index++;
		string ret = data[start .. index].stripRight(' ');
		enforceParser(ret.length > 0, "Invalid empty value");
		switch (ret)
		{
		case "true":
			return TOMLValue(true);
		case "false":
			return TOMLValue(false);
		case "inf":
		case "+inf":
			return TOMLValue(double.infinity);
		case "-inf":
			return TOMLValue(-double.infinity);
		case "nan":
		case "+nan":
			return TOMLValue(double.nan);
		case "-nan":
			return TOMLValue(-double.nan);
		default:
			immutable original = ret;
			try
			{
				if (ret.length >= 10 && ret[4] == '-' && ret[7] == '-')
				{
					// date or datetime
					if (ret.length >= 19 && (ret[10] == 'T' || ret[10] == ' ')
							&& ret[13] == ':' && ret[16] == ':')
					{
						// datetime
						if (ret[10] == ' ')
							ret = ret[0 .. 10] ~ 'T' ~ ret[11 .. $];
						if (ret[19 .. $].canFind("-") || ret[$ - 1] == 'Z')
						{
							// has timezone
							return TOMLValue(SysTime.fromISOExtString(ret));
						}
						else
						{
							// is space allowed instead of T?
							return TOMLValue(DateTime.fromISOExtString(ret));
						}
					}
					else
					{
						return TOMLValue(Date.fromISOExtString(ret));
					}
				}
				else if (ret.length >= 8 && ret[2] == ':' && ret[5] == ':')
				{
					return TOMLValue(TimeOfDay.fromISOExtString(ret));
				}
				if (ret.length > 2 && ret[0] == '0')
				{
					switch (ret[1])
					{
					case 'x':
						return TOMLValue(to!long(removeUnderscores(ret[2 .. $],
								"09", "AZ", "az"), 16));
					case 'o':
						return TOMLValue(to!long(removeUnderscores(ret[2 .. $], "08"), 8));
					case 'b':
						return TOMLValue(to!long(removeUnderscores(ret[2 .. $], "01"), 2));
					default:
						break;
					}
				}
				if (ret.canFind('.') || ret.canFind('e') || ret.canFind('E'))
				{
					return TOMLValue(to!double(removeUnderscores(ret, "09")));
				}
				else
				{
					if (ret[0] != '0' || ret.length == 1)
						return TOMLValue(to!long(removeUnderscores(ret, "09")));
				}
			}
			catch (Exception)
			{
			}
			// not a valid value at this point
			if (options & TOMLOptions.unquotedStrings)
				return TOMLValue(original);
			else
				error("Invalid type: '" ~ original ~ "'");
			assert(0);
		}
	}

	string readKey()
	{
		enforceParser(index < data.length, "Key declaration expected but found EOF");
		string ret;
		if (data[index] == '"')
		{
			index++;
			ret = readQuotedString!false();
		}
		else if (data[index] == '\'')
		{
			index++;
			ret = readSimpleQuotedString!false();
		}
		else
		{
			Appender!string appender;
			while (index < data.length && isValidKeyChar(data[index]))
			{
				appender.put(data[index++]);
			}
			ret = appender.data;
			enforceParser(ret.length != 0, "Key is empty or contains invalid characters");
		}
		return ret;
	}

	string[] readKeys()
	{
		string[] keys;
		index--;
		do
		{
			index++;
			clear!false();
			keys ~= readKey();
			clear!false();
		}
		while (index < data.length && data[index] == '.');
		enforceParser(keys.length != 0, "Key cannot be empty");
		return keys;
	}

	TOMLValue readValue()
	{
		if (index < data.length)
		{
			switch (data[index++])
			{
			case '"':
				if (index + 2 <= data.length && data[index .. index + 2] == "\"\"")
				{
					index += 2;
					return TOMLValue(readQuotedString!true());
				}
				else
				{
					return TOMLValue(readQuotedString!false());
				}
			case '\'':
				if (index + 2 <= data.length && data[index .. index + 2] == "''")
				{
					index += 2;
					return TOMLValue(readSimpleQuotedString!true());
				}
				else
				{
					return TOMLValue(readSimpleQuotedString!false());
				}
			case '[':
				clear();
				TOMLValue[] array;
				bool comma = true;
				while (data[index] != ']')
				{ //TODO check range error
					enforceParser(comma, "Elements of the array must be separated with a comma");
					array ~= readValue();
					clear!false(); // spaces allowed between elements and commas
					if (data[index] == ',')
					{ //TODO check range error
						index++;
						comma = true;
					}
					else
					{
						comma = false;
					}
					clear(); // spaces and newlines allowed between elements
				}
				index++;
				return TOMLValue(array);
			case '{':
				clear!false();
				TOMLValue[string] table;
				bool comma = true;
				while (data[index] != '}')
				{ //TODO check range error
					enforceParser(comma, "Elements of the table must be separated with a comma");
					auto keys = readKeys();
					enforceParser(clear!false() && data[index++] == '='
							&& clear!false(), "Expected value after key declaration");
					setImpl(&table, keys, keys, readValue());
					enforceParser(clear!false(),
							"Expected ',' or '}' but found " ~ (index < data.length ? "EOL" : "EOF"));
					if (data[index] == ',')
					{
						index++;
						comma = true;
					}
					else
					{
						comma = false;
					}
					clear!false();
				}
				index++;
				return TOMLValue(table);
			default:
				index--;
				break;
			}
		}
		return readSpecial();
	}

	void readKeyValue(string[] keys)
	{
		if (clear())
		{
			enforceParser(data[index++] == '=', "Expected '=' after key declaration");
			if (clear!false())
			{
				set(keys, readValue());
				// there must be nothing after the key/value declaration except comments and whitespaces
				if (clear!false())
					enforceParser(data[index] == '\n',
							"Invalid characters after value declaration: " ~ data[index]);
			}
			else
			{
				//TODO throw exception (missing value)
			}
		}
		else
		{
			//TODO throw exception (missing value)
		}
	}

	void next()
	{

		if (data[index] == '[')
		{
			current = &_ret; // reset base
			index++;
			bool array = false;
			if (index < data.length && data[index] == '[')
			{
				index++;
				array = true;
			}
			string[] keys = readKeys();
			enforceParser(index < data.length && data[index++] == ']',
					"Invalid " ~ (array ? "array" : "table") ~ " key declaration");
			if (array)
				enforceParser(index < data.length && data[index++] == ']',
						"Invalid array key declaration");
			if (!array)
			{
				//TODO only enforce if every key is a table
				enforceParser(!tableNames.canFind(keys),
						"Table name has already been directly defined");
				tableNames ~= keys;
			}
			void update(string key, bool allowArray = true)
			{
				if (key !in *current)
					set([key], TOMLValue(TOML_TYPE.TABLE));
				auto ret = (*current)[key];
				if (ret.type == TOML_TYPE.TABLE)
					current = &((*current)[key].table());
				else if (allowArray && ret.type == TOML_TYPE.ARRAY)
					current = &((*current)[key].array[$ - 1].table());
				else
					error("Invalid type");
			}

			foreach (immutable key; keys[0 .. $ - 1])
			{
				update(key);
			}
			if (array)
			{
				auto exist = keys[$ - 1] in *current;
				if (exist)
				{
					//TODO must be an array
					(*exist).array ~= TOMLValue(TOML_TYPE.TABLE);
				}
				else
				{
					set([keys[$ - 1]], TOMLValue([TOMLValue(TOML_TYPE.TABLE)]));
				}
				current = &((*current)[keys[$ - 1]].array[$ - 1].table());
			}
			else
			{
				update(keys[$ - 1], false);
			}
		}
		else
		{
			readKeyValue(readKeys());
		}

	}

	while (clear())
	{
		next();
	}

	return TOMLDocument(_ret);

}

private @property string stripFirstLine(string data)
{
	size_t i = 0;
	while (i < data.length && data[i] != '\n')
		i++;
	if (data[0 .. i].strip.length == 0)
		return data[i + 1 .. $];
	else
		return data;
}

version (Windows)
{
	// convert posix's line ending to windows'
	private enum doLineConversion = q{
		if(data[index] == '\n' && index != 0 && data[index-1] != '\r') {
			index++;
			ret.put("\r\n");
			continue;
		}
	};
}
else
{
	// convert windows' line ending to posix's
	private enum doLineConversion = q{
		if(data[index] == '\r' && index + 1 < data.length && data[index+1] == '\n') {
			index += 2;
			ret.put("\n");
			continue;
		}
	};
}

unittest
{

	TOMLDocument doc;

	// tests from the official documentation
	// https://github.com/toml-lang/toml/blob/master/README.md

	doc = parseTOML(`
		# This is a TOML document.

		title = "TOML Example"

		[owner]
		name = "Tom Preston-Werner"
		dob = 1979-05-27T07:32:00-08:00 # First class dates

		[database]
		server = "192.168.1.1"
		ports = [ 8001, 8001, 8002 ]
		connection_max = 5000
		enabled = true

		[servers]

		  # Indentation (tabs and/or spaces) is allowed but not required
		  [servers.alpha]
		  ip = "10.0.0.1"
		  dc = "eqdc10"

		  [servers.beta]
		  ip = "10.0.0.2"
		  dc = "eqdc10"

		[clients]
		data = [ ["gamma", "delta"], [1, 2] ]

		# Line breaks are OK when inside arrays
		hosts = [
		  "alpha",
		  "omega"
		]
	`);
	assert(doc["title"] == "TOML Example");
	assert(doc["owner"]["name"] == "Tom Preston-Werner");
	assert(doc["owner"]["dob"] == SysTime.fromISOExtString("1979-05-27T07:32:00-08:00"));
	assert(doc["database"]["server"] == "192.168.1.1");
	assert(doc["database"]["ports"] == [8001, 8001, 8002]);
	assert(doc["database"]["connection_max"] == 5000);
	assert(doc["database"]["enabled"] == true);
	//TODO
	assert(doc["clients"]["data"][0] == ["gamma", "delta"]);
	assert(doc["clients"]["data"][1] == [1, 2]);
	assert(doc["clients"]["hosts"] == ["alpha", "omega"]);

	doc = parseTOML(`
		# This is a full-line comment
		key = "value"
	`);
	assert("key" in doc);
	assert(doc["key"].type == TOML_TYPE.STRING);
	assert(doc["key"].str == "value");

	foreach (k, v; doc)
	{
		assert(k == "key");
		assert(v.type == TOML_TYPE.STRING);
		assert(v.str == "value");
	}

	assertThrown!TOMLException({ parseTOML(`key = # INVALID`); }());
	assertThrown!TOMLException({ parseTOML("key =\nkey2 = 'test'"); }());

	// ----
	// Keys
	// ----

	// bare keys
	doc = parseTOML(`
		key = "value"
		bare_key = "value"
		bare-key = "value"
		1234 = "value"
	`);
	assert(doc["key"] == "value");
	assert(doc["bare_key"] == "value");
	assert(doc["bare-key"] == "value");
	assert(doc["1234"] == "value");

	// quoted keys
	doc = parseTOML(`
		"127.0.0.1" = "value"
		"character encoding" = "value"
		"ʎǝʞ" = "value"
		'key2' = "value"
		'quoted "value"' = "value"
	`);
	assert(doc["127.0.0.1"] == "value");
	assert(doc["character encoding"] == "value");
	assert(doc["ʎǝʞ"] == "value");
	assert(doc["key2"] == "value");
	assert(doc["quoted \"value\""] == "value");

	// no key name
	assertThrown!TOMLException({ parseTOML(`= "no key name" # INVALID`); }());

	// empty key
	assert(parseTOML(`"" = "blank"`)[""] == "blank");
	assert(parseTOML(`'' = 'blank'`)[""] == "blank");

	// dotted keys
	doc = parseTOML(`
		name = "Orange"
		physical.color = "orange"
		physical.shape = "round"
		site."google.com" = true
	`);
	assert(doc["name"] == "Orange");
	assert(doc["physical"] == ["color" : "orange", "shape" : "round"]);
	assert(doc["site"]["google.com"] == true);

	// ------
	// String
	// ------

	// basic strings
	doc = parseTOML(`str = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."`);
	assert(doc["str"] == "I'm a string. \"You can quote me\". Name\tJosé\nLocation\tSF.");

	// multi-line basic strings
	doc = parseTOML(`str1 = """
Roses are red
Violets are blue"""`);
	version (Posix)
		assert(doc["str1"] == "Roses are red\nViolets are blue");
	else
		assert(doc["str1"] == "Roses are red\r\nViolets are blue");

	doc = parseTOML(`
		# The following strings are byte-for-byte equivalent:
		str1 = "The quick brown fox jumps over the lazy dog."
		
		str2 = """
The quick brown \


		  fox jumps over \
		    the lazy dog."""
		
		str3 = """\
			The quick brown \
			fox jumps over \
			the lazy dog.\
       """`);
	assert(doc["str1"] == "The quick brown fox jumps over the lazy dog.");
	assert(doc["str1"] == doc["str2"]);
	assert(doc["str1"] == doc["str3"]);

	// literal strings
	doc = parseTOML(`
		# What you see is what you get.
		winpath  = 'C:\Users\nodejs\templates'
		winpath2 = '\\ServerX\admin$\system32\'
		quoted   = 'Tom "Dubs" Preston-Werner'
		regex    = '<\i\c*\s*>'
	`);
	assert(doc["winpath"] == `C:\Users\nodejs\templates`);
	assert(doc["winpath2"] == `\\ServerX\admin$\system32\`);
	assert(doc["quoted"] == `Tom "Dubs" Preston-Werner`);
	assert(doc["regex"] == `<\i\c*\s*>`);

	// multi-line literal strings
	doc = parseTOML(`
		regex2 = '''I [dw]on't need \d{2} apples'''
		lines  = '''
The first newline is
trimmed in raw strings.
   All other whitespace
   is preserved.
'''`);
	assert(doc["regex2"] == `I [dw]on't need \d{2} apples`);
	assert(doc["lines"] == "The first newline is" ~ newline ~ "trimmed in raw strings."
			~ newline ~ "   All other whitespace" ~ newline ~ "   is preserved." ~ newline);

	// -------
	// Integer
	// -------

	doc = parseTOML(`
		int1 = +99
		int2 = 42
		int3 = 0
		int4 = -17
	`);
	assert(doc["int1"].type == TOML_TYPE.INTEGER);
	assert(doc["int1"].integer == 99);
	assert(doc["int2"] == 42);
	assert(doc["int3"] == 0);
	assert(doc["int4"] == -17);

	doc = parseTOML(`
		int5 = 1_000
		int6 = 5_349_221
		int7 = 1_2_3_4_5     # VALID but discouraged
	`);
	assert(doc["int5"] == 1_000);
	assert(doc["int6"] == 5_349_221);
	assert(doc["int7"] == 1_2_3_4_5);

	// leading 0s not allowed
	assertThrown!TOMLException({ parseTOML(`invalid = 01`); }());

	// underscores must be enclosed in numbers
	assertThrown!TOMLException({ parseTOML(`invalid = _123`); }());
	assertThrown!TOMLException({ parseTOML(`invalid = 123_`); }());
	assertThrown!TOMLException({ parseTOML(`invalid = 123__123`); }());
	assertThrown!TOMLException({ parseTOML(`invalid = 0b01_21`); }());
	assertThrown!TOMLException({ parseTOML(`invalid = 0x_deadbeef`); }());
	assertThrown!TOMLException({ parseTOML(`invalid = 0b0101__00`); }());

	doc = parseTOML(`
		# hexadecimal with prefix 0x
		hex1 = 0xDEADBEEF
		hex2 = 0xdeadbeef
		hex3 = 0xdead_beef

		# octal with prefix 0o
		oct1 = 0o01234567
		oct2 = 0o755 # useful for Unix file permissions

		# binary with prefix 0b
		bin1 = 0b11010110
	`);
	assert(doc["hex1"] == 0xDEADBEEF);
	assert(doc["hex2"] == 0xdeadbeef);
	assert(doc["hex3"] == 0xdead_beef);
	assert(doc["oct1"] == 342391);
	assert(doc["oct2"] == 493);
	assert(doc["bin1"] == 0b11010110);

	assertThrown!TOMLException({ parseTOML(`invalid = 0h111`); }());

	// -----
	// Float
	// -----

	doc = parseTOML(`
		# fractional
		flt1 = +1.0
		flt2 = 3.1415
		flt3 = -0.01

		# exponent
		flt4 = 5e+22
		flt5 = 1e6
		flt6 = -2E-2

		# both
		flt7 = 6.626e-34
	`);
	assert(doc["flt1"].type == TOML_TYPE.FLOAT);
	assert(doc["flt1"].floating == 1);
	assert(doc["flt2"] == 3.1415);
	assert(doc["flt3"] == -.01);
	assert(doc["flt4"] == 5e+22);
	assert(doc["flt5"] == 1e6);
	assert(doc["flt6"] == -2E-2);
	assert(doc["flt7"] == 6.626e-34);

	doc = parseTOML(`flt8 = 9_224_617.445_991_228_313`);
	assert(doc["flt8"] == 9_224_617.445_991_228_313);

	doc = parseTOML(`
		# infinity
		sf1 = inf  # positive infinity
		sf2 = +inf # positive infinity
		sf3 = -inf # negative infinity

		# not a number
		sf4 = nan  # actual sNaN/qNaN encoding is implementation specific
		sf5 = +nan # same as nan
		sf6 = -nan # valid, actual encoding is implementation specific
	`);
	assert(doc["sf1"] == double.infinity);
	assert(doc["sf2"] == double.infinity);
	assert(doc["sf3"] == -double.infinity);
	assert(doc["sf4"].floating.isNaN());
	assert(doc["sf5"].floating.isNaN());
	assert(doc["sf6"].floating.isNaN());

	// -------
	// Boolean
	// -------

	doc = parseTOML(`
		bool1 = true
		bool2 = false
	`);
	assert(doc["bool1"].type == TOML_TYPE.TRUE);
	assert(doc["bool2"].type == TOML_TYPE.FALSE);
	assert(doc["bool1"] == true);
	assert(doc["bool2"] == false);

	// ----------------
	// Offset Date-Time
	// ----------------

	doc = parseTOML(`
		odt1 = 1979-05-27T07:32:00Z
		odt2 = 1979-05-27T00:32:00-07:00
		odt3 = 1979-05-27T00:32:00.999999-07:00
	`);
	assert(doc["odt1"].type == TOML_TYPE.OFFSET_DATETIME);
	assert(doc["odt1"].offsetDatetime == SysTime.fromISOExtString("1979-05-27T07:32:00Z"));
	assert(doc["odt2"] == SysTime.fromISOExtString("1979-05-27T00:32:00-07:00"));
	assert(doc["odt3"] == SysTime.fromISOExtString("1979-05-27T00:32:00.999999-07:00"));

	doc = parseTOML(`odt4 = 1979-05-27 07:32:00Z`);
	assert(doc["odt4"] == SysTime.fromISOExtString("1979-05-27T07:32:00Z"));

	// ---------------
	// Local Date-Time
	// ---------------

	doc = parseTOML(`
		ldt1 = 1979-05-27T07:32:00
		ldt2 = 1979-05-27T00:32:00.999999
	`);
	assert(doc["ldt1"].type == TOML_TYPE.LOCAL_DATETIME);
	assert(doc["ldt1"].localDatetime == DateTime.fromISOExtString("1979-05-27T07:32:00"));
	assert(doc["ldt2"] == DateTime.fromISOExtString("1979-05-27T00:32:00.999999"));

	// ----------
	// Local Date
	// ----------

	doc = parseTOML(`
		ld1 = 1979-05-27
	`);
	assert(doc["ld1"].type == TOML_TYPE.LOCAL_DATE);
	assert(doc["ld1"].localDate == Date.fromISOExtString("1979-05-27"));

	// ----------
	// Local Time
	// ----------

	doc = parseTOML(`
		lt1 = 07:32:00
		lt2 = 00:32:00.999999
	`);
	assert(doc["lt1"].type == TOML_TYPE.LOCAL_TIME);
	assert(doc["lt1"].localTime == TimeOfDay.fromISOExtString("07:32:00"));
	assert(doc["lt2"] == TimeOfDay.fromISOExtString("00:32:00.999999"));
	assert(doc["lt2"].localTime.fracSecs.total!"msecs" == 999999);

	// -----
	// Array
	// -----

	doc = parseTOML(`
		arr1 = [ 1, 2, 3 ]
		arr2 = [ "red", "yellow", "green" ]
		arr3 = [ [ 1, 2 ], [3, 4, 5] ]
		arr4 = [ "all", 'strings', """are the same""", '''type''']
		arr5 = [ [ 1, 2 ], ["a", "b", "c"] ]
	`);
	assert(doc["arr1"].type == TOML_TYPE.ARRAY);
	assert(doc["arr1"].array == [TOMLValue(1), TOMLValue(2), TOMLValue(3)]);
	assert(doc["arr2"] == ["red", "yellow", "green"]);
	assert(doc["arr3"] == [[1, 2], [3, 4, 5]]);
	assert(doc["arr4"] == ["all", "strings", "are the same", "type"]);
	assert(doc["arr5"] == [TOMLValue([1, 2]), TOMLValue(["a", "b", "c"])]);

	assertThrown!TOMLException({ parseTOML(`arr6 = [ 1, 2.0 ]`); }());

	doc = parseTOML(`
		arr7 = [
		  1, 2, 3
		]

		arr8 = [
		  1,
		  2, # this is ok
		]
	`);
	assert(doc["arr7"] == [1, 2, 3]);
	assert(doc["arr8"] == [1, 2]);

	// -----
	// Table
	// -----

	doc = parseTOML(`
		[table-1]
		key1 = "some string"
		key2 = 123
		
		[table-2]
		key1 = "another string"
		key2 = 456
	`);
	assert(doc["table-1"].type == TOML_TYPE.TABLE);
	assert(doc["table-1"] == ["key1" : TOMLValue("some string"), "key2" : TOMLValue(123)]);
	assert(doc["table-2"] == ["key1" : TOMLValue("another string"), "key2" : TOMLValue(456)]);

	doc = parseTOML(`
		[dog."tater.man"]
		type.name = "pug"
	`);
	assert(doc["dog"]["tater.man"]["type"]["name"] == "pug");

	doc = parseTOML(`
		[a.b.c]            # this is best practice
		[ d.e.f ]          # same as [d.e.f]
		[ g .  h  . i ]    # same as [g.h.i]
		[ j . "ʞ" . 'l' ]  # same as [j."ʞ".'l']
	`);
	assert(doc["a"]["b"]["c"].type == TOML_TYPE.TABLE);
	assert(doc["d"]["e"]["f"].type == TOML_TYPE.TABLE);
	assert(doc["g"]["h"]["i"].type == TOML_TYPE.TABLE);
	assert(doc["j"]["ʞ"]["l"].type == TOML_TYPE.TABLE);

	doc = parseTOML(`
		# [x] you
		# [x.y] don't
		# [x.y.z] need these
		[x.y.z.w] # for this to work
	`);
	assert(doc["x"]["y"]["z"]["w"].type == TOML_TYPE.TABLE);

	doc = parseTOML(`
		[a.b]
		c = 1
		
		[a]
		d = 2
	`);
	assert(doc["a"]["b"]["c"] == 1);
	assert(doc["a"]["d"] == 2);

	assertThrown!TOMLException({ parseTOML(`
			# DO NOT DO THIS
				
			[a]
			b = 1
			
			[a]
			c = 2
		`); }());

	assertThrown!TOMLException({ parseTOML(`
			# DO NOT DO THIS EITHER

			[a]
			b = 1

			[a.b]
			c = 2
		`); }());

	assertThrown!TOMLException({ parseTOML(`[]`); }());
	assertThrown!TOMLException({ parseTOML(`[a.]`); }());
	assertThrown!TOMLException({ parseTOML(`[a..b]`); }());
	assertThrown!TOMLException({ parseTOML(`[.b]`); }());
	assertThrown!TOMLException({ parseTOML(`[.]`); }());

	// ------------
	// Inline Table
	// ------------

	doc = parseTOML(`
		name = { first = "Tom", last = "Preston-Werner" }
		point = { x = 1, y = 2 }
		animal = { type.name = "pug" }
	`);
	assert(doc["name"]["first"] == "Tom");
	assert(doc["name"]["last"] == "Preston-Werner");
	assert(doc["point"] == ["x" : 1, "y" : 2]);
	assert(doc["animal"]["type"]["name"] == "pug");

	// ---------------
	// Array of Tables
	// ---------------

	doc = parseTOML(`
		[[products]]
		name = "Hammer"
		sku = 738594937
		
		[[products]]
		
		[[products]]
		name = "Nail"
		sku = 284758393
		color = "gray"
	`);
	assert(doc["products"].type == TOML_TYPE.ARRAY);
	assert(doc["products"].array.length == 3);
	assert(doc["products"][0] == ["name" : TOMLValue("Hammer"), "sku" : TOMLValue(738594937)]);
	assert(doc["products"][1] == (TOMLValue[string]).init);
	assert(doc["products"][2] == ["name" : TOMLValue("Nail"), "sku"
			: TOMLValue(284758393), "color" : TOMLValue("gray")]);

	// nested
	doc = parseTOML(`
		[[fruit]]
		  name = "apple"

		  [fruit.physical]
		    color = "red"
		    shape = "round"

		  [[fruit.variety]]
		    name = "red delicious"

		  [[fruit.variety]]
		    name = "granny smith"

		[[fruit]]
		  name = "banana"

		  [[fruit.variety]]
		    name = "plantain"
	`);
	assert(doc["fruit"].type == TOML_TYPE.ARRAY);
	assert(doc["fruit"].array.length == 2);
	assert(doc["fruit"][0]["name"] == "apple");
	assert(doc["fruit"][0]["physical"] == ["color" : "red", "shape" : "round"]);
	assert(doc["fruit"][0]["variety"][0] == ["name" : "red delicious"]);
	assert(doc["fruit"][0]["variety"][1]["name"] == "granny smith");
	assert(doc["fruit"][1] == ["name" : TOMLValue("banana"), "variety"
			: TOMLValue([["name" : "plantain"]])]);

	assertThrown!TOMLException({ parseTOML(`
			# INVALID TOML DOC
			[[fruit]]
			  name = "apple"

			  [[fruit.variety]]
			    name = "red delicious"

			  # This table conflicts with the previous table
			  [fruit.variety]
			    name = "granny smith"
		`); }());

	doc = parseTOML(`
		points = [ { x = 1, y = 2, z = 3 },
			{ x = 7, y = 8, z = 9 },
			{ x = 2, y = 4, z = 8 } ]
	`);
	assert(doc["points"].array.length == 3);
	assert(doc["points"][0] == ["x" : 1, "y" : 2, "z" : 3]);
	assert(doc["points"][1] == ["x" : 7, "y" : 8, "z" : 9]);
	assert(doc["points"][2] == ["x" : 2, "y" : 4, "z" : 8]);

	// additional tests for code coverage

	assert(TOMLValue(42) == 42.0);
	assert(TOMLValue(42) != "42");
	assert(TOMLValue("42") != 42);

	try
	{
		parseTOML(`
			
			error = @		
		`);
	}
	catch (TOMLParserException e)
	{
		assert(e.position.line == 3); // start from line 1
		assert(e.position.column == 9 + 3); // 3 tabs
	}

	assertThrown!TOMLException({ parseTOML(`error = "unterminated`); }());
	assertThrown!TOMLException({ parseTOML(`error = 'unterminated`); }());
	assertThrown!TOMLException({ parseTOML(`error = "\ "`); }());

	assertThrown!TOMLException({ parseTOML(`error = truè`); }());
	assertThrown!TOMLException({ parseTOML(`error = falsè`); }());

	assertThrown!TOMLException({ parseTOML(`[error`); }());

	doc = parseTOML(`test = "\\\"\b\t\n\f\r\u0040\U00000040"`);
	assert(doc["test"] == "\\\"\b\t\n\f\r@@");

	doc = parseTOML(`test = """quoted "string"!"""`);
	assert(doc["test"] == "quoted \"string\"!");

	// options

	assert(parseTOML(`raw = this is unquoted`,
			TOMLOptions.unquotedStrings)["raw"] == "this is unquoted");

	// document

	TOMLValue value = TOMLValue(["test" : 44]);
	doc = TOMLDocument(value);

	// opEquals

	assert(TOMLValue(true) == TOMLValue(true));
	assert(TOMLValue("string") == TOMLValue("string"));
	assert(TOMLValue(0) == TOMLValue(0));
	assert(TOMLValue(.0) == TOMLValue(.0));
	assert(TOMLValue(SysTime.fromISOExtString("1979-05-27T00:32:00-07:00")) == TOMLValue(
			SysTime.fromISOExtString("1979-05-27T00:32:00-07:00")));
	assert(TOMLValue(DateTime.fromISOExtString("1979-05-27T07:32:00")) == TOMLValue(
			DateTime.fromISOExtString("1979-05-27T07:32:00")));
	assert(TOMLValue(Date.fromISOExtString("1979-05-27")) == TOMLValue(
			Date.fromISOExtString("1979-05-27")));
	assert(TOMLValue(TimeOfDay.fromISOExtString("07:32:00")) == TOMLValue(
			TimeOfDay.fromISOExtString("07:32:00")));
	assert(TOMLValue([1, 2, 3]) == TOMLValue([1, 2, 3]));
	assert(TOMLValue(["a" : 0, "b" : 1]) == TOMLValue(["a" : 0, "b" : 1]));

	// toString()

	assert(TOMLDocument(["test" : TOMLValue(0)]).toString() == "test = 0" ~ newline);

	assert(TOMLValue(true).toString() == "true");
	assert(TOMLValue("string").toString() == "\"string\"");
	assert(TOMLValue("\"quoted \\ \b \f \r\n \t string\"")
			.toString() == "\"\\\"quoted \\\\ \\b \\f \\r\\n \\t string\\\"\"");
	assert(TOMLValue(42).toString() == "42");
	assert(TOMLValue(99.44).toString() == "99.44");
	assert(TOMLValue(.0).toString() == "0.0");
	assert(TOMLValue(1e100).toString() == "1e+100");
	assert(TOMLValue(SysTime.fromISOExtString("1979-05-27T00:32:00-07:00"))
			.toString() == "1979-05-27T00:32:00-07:00");
	assert(TOMLValue(DateTime.fromISOExtString("1979-05-27T07:32:00"))
			.toString() == "1979-05-27T07:32:00");
	assert(TOMLValue(Date.fromISOExtString("1979-05-27")).toString() == "1979-05-27");
	assert(TOMLValue(TimeOfDay.fromISOExtString("07:32:00.999999")).toString() == "07:32:00.999999");
	assert(TOMLValue([1, 2, 3]).toString() == "[1, 2, 3]");
	immutable table = TOMLValue(["a" : 0, "b" : 1]).toString();
	assert(table == "{ a = 0, b = 1 }" || table == "{ b = 1, a = 0 }");

	foreach (key, value; TOMLValue(["0" : 0, "1" : 1]))
	{
		assert(value == key.to!int);
	}

	value = 42;
	assert(value.type == TOML_TYPE.INTEGER);
	assert(value == 42);
	value = TOMLValue("42");
	assert(value.type == TOML_TYPE.STRING);
	assert(value == "42");

}

/**
 * Exception thrown on generic TOML errors.
 */
class TOMLException : Exception
{

	public this(string message, string file = __FILE__, size_t line = __LINE__)
	{
		super(message, file, line);
	}

}

/**
 * Exception thrown during the parsing of TOML document.
 */
class TOMLParserException : TOMLException
{

	private Tuple!(size_t, "line", size_t, "column") _position;

	public this(string message, size_t line, size_t column, string file = __FILE__,
			size_t _line = __LINE__)
	{
		super(message ~ " (" ~ to!string(line) ~ ":" ~ to!string(column) ~ ")", file, _line);
		this._position.line = line;
		this._position.column = column;
	}

	/**
	 * Gets the position (line and column) where the parsing expection
	 * has occured.
	 */
	public pure nothrow @property @safe @nogc auto position()
	{
		return this._position;
	}

}