//          Copyright Brian Schott (Sir Alaran) 2012.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

module tokenizer;

import std.range;
import std.file;
import std.traits;
import std.algorithm;
import std.conv;
import std.uni;
import std.stdio;
import std.ascii;
import std.format;

import langutils;
import codegen;
import entities;

pure bool isNewline(R)(R range)
{
	return range.front == '\n' || range.front == '\r';
}

pure bool isEoF(R)(R range)
{
	return range.empty || range.front == 0 || range.front == 0x1a;
}

char[] popNewline(R)(ref R range)
{
	char[] chars;
	if (range.front == '\r')
	{
		chars ~= range.front;
		range.popFront();
	}
	if (range.front == '\n')
	{
		chars ~= range.front;
		range.popFront();
	}
	return chars;
}

unittest
{
	auto s = "\r\ntest";
	assert (popNewline(s) == "\r\n");
	assert (s == "test");
}

/**
 * Returns:
 */
string lexWhitespace(R)(ref R range, ref uint lineNumber)
{
	auto app = appender!(char[])();
	while (!isEoF(range) && std.uni.isWhite(range.front))
	{
		if (isNewline(range))
		{
		++lineNumber;
			app.put(popNewline(range));
		}
		else
		{
			app.put(range.front);
			range.popFront();
		}
	}
	return to!string(app.data);
}

unittest
{
	import std.stdio;
	uint lineNum = 1;
	auto chars = " \n \r\n \tabcde";
	auto r = lexWhitespace(chars, lineNum);
	assert (r == " \n \r\n \t");
	assert (chars == "abcde");
	assert (lineNum == 3);
}

/**
 * Increments endIndex until it indexes a character directly after a comment
 * Params:
 *     inputString = the source code to examine
 *     endIndex = an index into inputString at the second character of a
 *     comment, i.e. points at the second slash in a // comment.
 *     lineNumber = the line number that corresponds to endIndex
 * Returns: The comment
 */
string lexComment(R)(ref R input, ref uint lineNumber)
in
{
	assert (input.front == '/');
}
body
{
	auto app = appender!(char[])();
	app.put(input.front);
	input.popFront();
	switch(input.front)
	{
	case '/':
		while (!isEoF(input) && !isNewline(input))
		{
			app.put(input.front);
			input.popFront();
		}
		break;
	case '*':
		while (!isEoF(input))
		{
			if (isNewline(input))
			{
				app.put(popNewline(input));
				++lineNumber;
		}
			else if (input.front == '*')
			{
				app.put(input.front);
				input.popFront();
				if (input.front == '/')
				{
					app.put(input.front);
					input.popFront();
					break;
				}
			}
			else
			{
				app.put(input.front);
				input.popFront();
			}
		}
		break;
	case '+':
		int depth = 1;
		while (depth > 0 && !isEoF(input))
		{
			if (isNewline(input))
			{
				app.put(popNewline(input));
				lineNumber++;
		}
			else if (input.front == '+')
			{
				app.put(input.front);
				input.popFront();
				if (input.front == '/')
				{
					app.put(input.front);
					input.popFront();
					--depth;
				}
			}
			else if (input.front == '/')
			{
				app.put(input.front);
				input.popFront();
				if (input.front == '+')
				{
					app.put(input.front);
					input.popFront();
					++depth;
				}
			}
			else
			{
				app.put(input.front);
				input.popFront();
			}
		}
		break;
	default:
		break;
	}
	return to!string(app.data);
}

unittest
{
	uint lineNumber = 1;
	auto chars = "//this is a comment\r\nthis is not";
	auto comment = lexComment(chars, lineNumber);
	assert (chars == "\r\nthis is not");
	assert (comment == "//this is a comment");
}

unittest
{
	uint lineNumber = 1;
	auto chars = "/* this is a\n\tcomment\r\n */this is not";
	auto comment = lexComment(chars, lineNumber);
	assert (chars == "this is not");
	assert (comment == "/* this is a\n\tcomment\r\n */");
	assert (lineNumber == 3);
}

unittest
{
	uint lineNumber = 1;
	auto chars = "/+this is a /+c/+omm+/ent+/ \r\nthis+/ is not";
	auto comment = lexComment(chars, lineNumber);
	assert (chars == " is not");
	assert (comment == "/+this is a /+c/+omm+/ent+/ \r\nthis+/");
	assert (lineNumber == 2);
}

/**
 * Pops up to upTo hex chars from the input range and returns them as a string
 */
string popHexChars(R)(ref R input, uint upTo)
{
	auto app = appender!(char[])();
	for (uint i = 0; i != upTo; ++i)
	{
		if (isHexDigit(input.front))
		{
			app.put(input.front);
			input.popFront;
		}
		else
			break;
	}
	return to!string(app.data);
}

unittest
{
	auto a = "124ac82d3fqwerty";
	auto ra = popHexChars(a, uint.max);
	assert (a == "qwerty");
	assert (ra == "124ac82d3f");
	auto b = "08a7c2e3";
	auto rb = popHexChars(b, 4);
	assert (rb.length == 4);
	assert (rb == "08a7");
	assert (b == "c2e3");
}

string interpretEscapeSequence(R)(ref R input)
in
{
	assert(input.front == '\\');
}
body
{
	input.popFront();
	switch (input.front)
	{
	case '\'':
	case '\"':
	case '?':
	case '\\':
	case 0:
	case 0x1a:
		auto f = input.front;
		input.popFront();
		return to!string(f);
	case 'a': input.popFront(); return "\a";
	case 'b': input.popFront(); return "\b";
	case 'f': input.popFront(); return "\f";
	case 'n': input.popFront(); return "\n";
	case 'r': input.popFront(); return "\r";
	case 't': input.popFront(); return "\t";
	case 'v': input.popFront(); return "\v";
	case 'x':
		input.popFront();
		auto hexChars = popHexChars(input, 2);
		return to!string(cast(dchar) parse!uint(hexChars, 16));
	case '0': .. case '7':
		return "";
	case 'u':
		input.popFront();
		auto hexChars = popHexChars(input, 4);
		return to!string(cast(dchar) parse!uint(hexChars, 16));
	case 'U':
		input.popFront();
		auto hexChars = popHexChars(input, 8);
		return to!string(cast(dchar) parse!uint(hexChars, 16));
	case '&':
		input.popFront();
		auto entity = appender!(char[])();
		while (!input.isEoF() && input.front != ';')
		{
			entity.put(input.front);
			input.popFront();
		}
		if (!isEoF(input))
		{
			auto decoded = characterEntities[to!string(entity.data)];
			input.popFront();
			if (decoded !is null)
				return decoded;
		}
		return "";
	default:
		// This is an error
		return "";

	}
}

unittest
{
	auto a = "\\&";
	assert (interpretEscapeSequence(a) == x"0026");
	auto b = "\\𝔞";
	assert (interpretEscapeSequence(b) == x"D835DD1E");
	auto c = "\\n";
	assert (interpretEscapeSequence(c) == "\n");
	auto d = "\\?";
	assert (interpretEscapeSequence(d) == "?");
	auto e = "\\u0033";
	assert (interpretEscapeSequence(e) == "\u0033");
	auto f = "\\U00000094";
	assert (interpretEscapeSequence(f) == "\U00000094");
}

/**
 * Params:
 *     inputString = the source code to examine
 *     endIndex = an index into inputString at the opening quote
 *     lineNumber = the line number that corresponds to endIndex
 *     quote = the opening (and closing) quote character for the string to be
 *         lexed
 * Returns: a string literal, including its opening and closing quote characters
 */
string lexString(R, C)(ref R input, ref uint lineNumber,
	C quote, bool canEscape = true) if (is (ElementType!(R) == C))
in
{
	assert (input.front == quote);
	assert (quote == '\'' || quote == '"' || quote == '`');
}
body
{
	auto app = appender!(char[])();
	while (!isEoF(input) && (input.front != quote || escape))
	{
		if (isNewline(input))
		{
			app.put(popNewline(input));
			lineNumber++;
		}
	}
	return to!string(app.data);
}

///**
// * Lexes the various crazy D string literals such as q{}, q"WTF is this? WTF",
// * and q"<>".
// * Params:
// *     inputString = the source code to examine
// *     endIndex = an index into inputString at the opening quote
// *     lineNumber = the line number that corresponds to endIndex
// * Returns: a string literal, including its opening and closing quote characters
// */
//string lexDelimitedString(S)(ref S inputString, ref size_t endIndex,
//	ref uint lineNumber) if (isSomeString!S)
//{
//	auto startIndex = endIndex;
//	++endIndex;
//	assert(!isEoF(inputString, endIndex)); // todo: what should happen if this is EoF?
//	string open = inputString[endIndex .. endIndex + 1];
//	string close;
//	bool nesting = false;
//	switch (open[0])
//	{
//	case '[': close = "]"; ++endIndex; nesting = true; break;
//	case '<': close = ">"; ++endIndex; nesting = true; break;
//	case '{': close = "}"; ++endIndex; nesting = true; break;
//	case '(': close = ")"; ++endIndex; nesting = true; break;
//	default:
//		while(!isEoF(inputString, endIndex) && !isWhite(inputString[endIndex]))
//			endIndex++;
//		close = open = inputString[startIndex + 1 .. endIndex];
//		break;
//	}
//	int depth = 1;
//	while (!isEoF(inputString, endIndex) && depth > 0)
//	{
//		if (inputString[endIndex] == '\n')
//		{
//			lineNumber++;
//			endIndex++;
//		}
//		else if (inputString[endIndex..$].startsWith(open))
//		{
//			endIndex += open.length;
//			if (!nesting && !isEoF(inputString, endIndex))
//			{
//				if (inputString[endIndex] == '"')
//					++endIndex;
//				break;
//			}
//			depth++;
//		}
//		else if (inputString[endIndex..$].startsWith(close))
//		{
//			endIndex += close.length;
//			depth--;
//			if (depth <= 0)
//				break;
//		}
//		else
//			++endIndex;
//	}
//	if (!isEoF(inputString, endIndex) && inputString[endIndex] == '"')
//		++endIndex;
//	return inputString[startIndex .. endIndex];
//}
//
//
///**
// * TODO: Fix this
// */
//string lexTokenString(S)(ref S inputString, ref size_t endIndex, ref uint lineNumber)
//{
//	/+auto r = byDToken(range, IterationStyle.EVERYTHING);
//	string s = getBraceContent(r);
//	range.popFrontN(s.length);
//	return s;+/
//	return "";
//}
//
//pure nothrow Token lexNumber(S)(ref S inputString, ref size_t endIndex)
//	if (isSomeString!S)
//{
//	Token token;
//	token.startIndex = endIndex;
//	size_t startIndex = endIndex;
//	if (inputString[endIndex] == '0')
//	{
//		endIndex++;
//		if (isEoF(inputString, endIndex))
//		{
//			token.type = TokenType.IntLiteral;
//			token.value = inputString[startIndex .. endIndex];
//			return token;
//		}
//		switch (inputString[endIndex])
//		{
//		case '0': .. case '9':
//			// The current language spec doesn't cover octal literals, so this
//			// is decimal.
//			lexDecimal(inputString, startIndex, endIndex, token);
//			return token;
//		case 'b':
//		case 'B':
//			lexBinary(inputString, startIndex, ++endIndex, token);
//			return token;
//		case 'x':
//		case 'X':
//			lexHex(inputString, startIndex, ++endIndex, token);
//			return token;
//		default:
//			token.type = TokenType.IntLiteral;
//			token.value = inputString[startIndex .. endIndex];
//			return token;
//		}
//	}
//	else
//	{
//		lexDecimal(inputString, startIndex, endIndex, token);
//		return token;
//	}
//}
//
//pure nothrow void lexBinary(S)(ref S inputString, size_t startIndex,
//	ref size_t endIndex, ref Token token) if (isSomeString!S)
//{
//	bool lexingSuffix = false;
//	bool isLong = false;
//	bool isUnsigned = false;
//	token.type = TokenType.IntLiteral;
//	binaryLoop: while (!isEoF(inputString, endIndex))
//	{
//		switch (inputString[endIndex])
//		{
//		case '0':
//		case '1':
//		case '_':
//			if (lexingSuffix)
//				break binaryLoop;
//			++endIndex;
//			break;
//		case 'u':
//		case 'U':
//			if (isUnsigned)
//				break;
//			++endIndex;
//			lexingSuffix = true;
//			if (isLong)
//			{
//				token.type = TokenType.UnsignedLongLiteral;
//				break binaryLoop;
//			}
//			else
//				token.type = TokenType.UnsignedIntLiteral;
//			isUnsigned = true;
//			break;
//		case 'L':
//			if (isLong)
//				break binaryLoop;
//			++endIndex;
//			lexingSuffix = true;
//			if (isUnsigned)
//			{
//				token.type = TokenType.UnsignedLongLiteral;
//				break binaryLoop;
//			}
//			else
//				token.type = TokenType.LongLiteral;
//			isLong = true;
//			break;
//		default:
//			break binaryLoop;
//		}
//	}
//
//	token.value = inputString[startIndex .. endIndex];
//}
//
//pure nothrow void lexDecimal(S)(ref S inputString, size_t startIndex,
//	ref size_t endIndex, ref Token token) if (isSomeString!S)
//{
//	bool lexingSuffix = false;
//	bool isLong = false;
//	bool isUnsigned = false;
//	bool isFloat = false;
//	bool isReal = false;
//	bool isDouble = false;
//	bool foundDot = false;
//	bool foundE = false;
//	bool foundPlusMinus = false;
//	token.type = TokenType.IntLiteral;
//	decimalLoop: while (!isEoF(inputString, endIndex))
//	{
//		switch (inputString[endIndex])
//		{
//		case '0': .. case '9':
//		case '_':
//			if (lexingSuffix)
//				break decimalLoop;
//			++endIndex;
//			break;
//		case 'e':
//		case 'E':
//			// For this to be a valid exponent, the next character must be a
//			// decimal character or a sign
//			if (foundE || isEoF(inputString, endIndex + 1))
//				break decimalLoop;
//			switch (inputString[endIndex + 1])
//			{
//			case '+':
//			case '-':
//				if (isEoF(inputString, endIndex + 2)
//					|| inputString[endIndex + 2] < '0'
//					|| inputString[endIndex + 2] > '9')
//				{
//					break decimalLoop;
//				}
//				break;
//			case '0': .. case '9':
//				break;
//			default:
//				break decimalLoop;
//			}
//			++endIndex;
//			foundE = true;
//			isDouble = true;
//			token.type = TokenType.DoubleLiteral;
//			break;
//		case '+':
//		case '-':
//			if (foundPlusMinus || !foundE)
//				break decimalLoop;
//			foundPlusMinus = true;
//			++endIndex;
//			break;
//		case '.':
//			if (!isEoF(inputString, endIndex + 1) && inputString[endIndex + 1] == '.')
//				break decimalLoop; // possibly slice expression
//			if (foundDot)
//				break decimalLoop; // two dots with other characters between them
//			++endIndex;
//			foundDot = true;
//			token.type = TokenType.DoubleLiteral;
//			isDouble = true;
//			break;
//		case 'u':
//		case 'U':
//			if (isUnsigned)
//				break decimalLoop;
//			++endIndex;
//			lexingSuffix = true;
//			if (isLong)
//				token.type = TokenType.UnsignedLongLiteral;
//			else
//				token.type = TokenType.UnsignedIntLiteral;
//			isUnsigned = true;
//			break;
//		case 'L':
//			if (isLong)
//				break decimalLoop;
//			if (isReal)
//				break decimalLoop;
//			++endIndex;
//			lexingSuffix = true;
//			if (isDouble)
//				token.type = TokenType.RealLiteral;
//			else if (isUnsigned)
//				token.type = TokenType.UnsignedLongLiteral;
//			else
//				token.type = TokenType.LongLiteral;
//			isLong = true;
//			break;
//		case 'f':
//		case 'F':
//			lexingSuffix = true;
//			if (isUnsigned || isLong)
//				break decimalLoop;
//			++endIndex;
//			token.type = TokenType.FloatLiteral;
//			break decimalLoop;
//		case 'i':
//			++endIndex;
//			// Spec says that this is the last suffix, so all cases break the
//			// loop.
//			if (isDouble)
//			{
//				token.type = TokenType.Idouble;
//				break decimalLoop;
//			}
//			else if (isFloat)
//			{
//				token.type = TokenType.Ifloat;
//				break decimalLoop;
//			}
//			else if (isReal)
//			{
//				token.type = TokenType.Ireal;
//				break decimalLoop;
//			}
//			else
//			{
//				// There is no imaginary int
//				--endIndex;
//				break decimalLoop;
//			}
//		default:
//			break decimalLoop;
//		}
//	}
//
//	token.value = inputString[startIndex .. endIndex];
//}
//
//
//unittest {
//	Token t;
//	size_t start, end;
//	lexDecimal!string("55e-4", start, end, t);
//	assert(t.value == "55e-4");
//	assert(t.type == TokenType.DoubleLiteral);
//
//	start = end = 0;
//	lexDecimal!string("123.45f", start, end, t);
//	assert(t.value == "123.45f");
//	assert(t.type == TokenType.FloatLiteral);
//
//	start = end = 0;
//	lexDecimal!string("3e+f", start, end, t);
//	assert(t.value == "3");
//	assert(t.type == TokenType.IntLiteral);
//
//	start = end = 0;
//	lexDecimal!string("3e++f", start, end, t);
//	assert(t.value == "3");
//	assert(t.type == TokenType.IntLiteral);
//
//	start = end = 0;
//	lexDecimal!string("1234..1237", start, end, t);
//	assert(t.value == "1234");
//	assert(t.type == TokenType.IntLiteral);
//}
//
//
//nothrow void lexHex(S)(ref S inputString, ref size_t startIndex,
//	ref size_t endIndex, ref Token token) if (isSomeString!S)
//{
//	bool lexingSuffix = false;
//	bool isLong = false;
//	bool isUnsigned = false;
//	bool isFloat = false;
//	bool isReal = false;
//	bool isDouble = false;
//	bool foundDot = false;
//	bool foundE = false;
//	bool foundPlusMinus = false;
//	token.type = TokenType.IntLiteral;
//	hexLoop: while (!isEoF(inputString, endIndex))
//	{
//		switch (inputString[endIndex])
//		{
//		case '0': .. case '9':
//		case 'a': .. case 'f':
//		case 'A': .. case 'F':
//		case '_':
//			if (lexingSuffix)
//				break hexLoop;
//			++endIndex;
//			break;
//		case 'p':
//		case 'P':
//			if (foundE)
//				break hexLoop;
//			++endIndex;
//			foundE = true;
//			break;
//		case '+':
//		case '-':
//			if (foundPlusMinus || !foundE)
//				break hexLoop;
//			foundPlusMinus = true;
//			++endIndex;
//			break;
//		case '.':
//			if (!isEoF(inputString, endIndex + 1) && inputString[endIndex + 1] == '.')
//				break hexLoop; // possibly slice expression
//			if (foundDot)
//				break hexLoop; // two dots with other characters between them
//			++endIndex;
//			foundDot = true;
//			token.type = TokenType.DoubleLiteral;
//			isDouble = true;
//			break;
//		default:
//			break hexLoop;
//		}
//	}
//
//	token.value = inputString[startIndex .. endIndex];
//}
//
//unittest
//{
//  Token t;
//	size_t start, end;
//  start = 0;
//  end = 2;
//  lexHex!string("0x193abfq", start, end, t);
//  assert(t.value == "0x193abf", t.value);
//  assert(t.type == TokenType.IntLiteral);
//
//  start = 0;
//  end = 2;
//  lexHex!string("0x2130xabc", start, end, t);
//  assert(t.value == "0x2130");
//  assert(t.type == TokenType.IntLiteral);
//
//}
//
///**
// * Returns: true if  ch marks the ending of one token and the beginning of
// *     another, false otherwise
// */
//pure nothrow bool isSeparating(C)(C ch) if (isSomeChar!C)
//{
//	switch (ch)
//	{
//		case '!': .. case '/':
//		case ':': .. case '@':
//		case '[': .. case '^':
//		case '{': .. case '~':
//		case 0x20: // space
//		case 0x09: // tab
//		case 0x0a: .. case 0x0d: // newline, vertical tab, form feed, carriage return
//			return true;
//		default:
//			return false;
//	}
//}
//
///**
// * Configure the tokenize() function
// */
//enum IterationStyle
//{
//	/// Only include code, not whitespace or comments
//	CODE_ONLY,
//	/// Include everything
//	EVERYTHING
//}
//
//struct TokenRange(R) if (isInputRange(R))
//{
//	bool empty() const @property
//	{
//		return _empty;
//	}
//
//
//private:
//	R range;
//	bool _empty;
//}
//
//Token[] tokenize(S)(S inputString, IterationStyle iterationStyle = IterationStyle.CODE_ONLY)
//	if (isSomeString!S)
//{
//	auto tokenAppender = appender!(Token[])();
//
//	// This is very likely a local maximum, but it does seem to take a few
//	// milliseconds off of the run time
//	tokenAppender.reserve(inputString.length / 4);
//
//	size_t endIndex = 0;
//	uint lineNumber = 1;
//
//	if (inputString.length > 1 && inputString[0..2] == "#!")
//	{
//		Token currentToken;
//		currentToken.lineNumber = lineNumber; // lineNumber is always 1
//		currentToken.value = lexScriptLine(inputString, endIndex, lineNumber);
//		currentToken.type = TokenType.ScriptLine;
//	}
//
//	while (!isEoF(inputString, endIndex))
//	{
//		size_t prevIndex = endIndex;
//		Token currentToken;
//		auto startIndex = endIndex;
//		if (isWhite(inputString[endIndex]))
//		{
//			if (iterationStyle == IterationStyle.EVERYTHING)
//			{
//				currentToken.lineNumber = lineNumber;
//				currentToken.value = lexWhitespace(inputString, endIndex,
//					lineNumber);
//				currentToken.type = TokenType.Whitespace;
//				tokenAppender.put(currentToken);
//			}
//			else
//				lexWhitespace(inputString, endIndex, lineNumber);
//			continue;
//		}
//		currentToken.startIndex = endIndex;
//
//		outerSwitch: switch(inputString[endIndex])
//		{
//		mixin(generateCaseTrie(
//			"=",    "TokenType.Assign",
//			"&",    "TokenType.BitAnd",
//			"&=",   "TokenType.BitAndEquals",
//			"|",    "TokenType.BitOr",
//			"|=",   "TokenType.BitOrEquals",
//			"~=",   "TokenType.CatEquals",
//			":",    "TokenType.Colon",
//			",",    "TokenType.Comma",
//			"$",    "TokenType.Dollar",
//			".",    "TokenType.Dot",
//			"==",   "TokenType.Equals",
//			"=>",   "TokenType.GoesTo",
//			">",    "TokenType.Greater",
//			">=",   "TokenType.GreaterEqual",
//			"#",    "TokenType.Hash",
//			"&&",   "TokenType.LogicAnd",
//			"{",    "TokenType.LBrace",
//			"[",    "TokenType.LBracket",
//			"<",    "TokenType.Less",
//			"<=",   "TokenType.LessEqual",
//			"<>=",  "TokenType.LessEqualGreater",
//			"<>",   "TokenType.LessOrGreater",
//			"||",   "TokenType.LogicOr",
//			"(",    "TokenType.LParen",
//			"-",    "TokenType.Minus",
//			"-=",   "TokenType.MinusEquals",
//			"%",    "TokenType.Mod",
//			"%=",   "TokenType.ModEquals",
//			"*=",   "TokenType.MulEquals",
//			"!",    "TokenType.Not",
//			"!=",   "TokenType.NotEquals",
//			"!>",   "TokenType.NotGreater",
//			"!>=",  "TokenType.NotGreaterEqual",
//			"!<",   "TokenType.NotLess",
//			"!<=",  "TokenType.NotLessEqual",
//			"!<>",  "TokenType.NotLessEqualGreater",
//			"+",    "TokenType.Plus",
//			"+=",   "TokenType.PlusEquals",
//			"^^",   "TokenType.Pow",
//			"^^=",  "TokenType.PowEquals",
//			"}",    "TokenType.RBrace",
//			"]",    "TokenType.RBracket",
//			")",    "TokenType.RParen",
//			";",    "TokenType.Semicolon",
//			"<<",   "TokenType.ShiftLeft",
//			"<<=",  "TokenType.ShiftLeftEqual",
//			">>",   "TokenType.ShiftRight",
//			">>=",  "TokenType.ShiftRightEqual",
//			"..",   "TokenType.Slice",
//			"*",    "TokenType.Star",
//			"?",    "TokenType.Ternary",
//			"~",    "TokenType.Tilde",
//			"--",   "TokenType.Decrement",
//			"!<>=", "TokenType.Unordered",
//			">>>",  "TokenType.UnsignedShiftRight",
//			">>>=", "TokenType.UnsignedShiftRightEqual",
//			"++",   "TokenType.Increment",
//			"...",  "TokenType.Vararg",
//			"^",    "TokenType.Xor",
//			"^=",   "TokenType.XorEquals",
//		));
//		case '0': .. case '9':
//			currentToken = lexNumber(inputString, endIndex);
//			break;
//		case '/':
//			++endIndex;
//			if (isEoF(inputString, endIndex))
//			{
//				currentToken.value = "/";
//				currentToken.type = TokenType.Div;
//				currentToken.lineNumber = lineNumber;
//				break;
//			}
//			currentToken.lineNumber = lineNumber;
//			switch (inputString[endIndex])
//			{
//			case '/':
//			case '+':
//			case '*':
//				if (iterationStyle == IterationStyle.CODE_ONLY)
//				{
//					lexComment(inputString, endIndex, lineNumber);
//					continue;
//				}
//				else
//				{
//					currentToken.value = lexComment(inputString, endIndex, lineNumber);
//					currentToken.type = TokenType.Comment;
//					break;
//				}
//			case '=':
//				currentToken.value = "/=";
//				currentToken.type = TokenType.DivEquals;
//				++endIndex;
//				break;
//			default:
//				currentToken.value = "/";
//				currentToken.type = TokenType.Div;
//				break;
//			}
//			break;
//		case 'r':
//			++endIndex;
//			if (isEoF(inputString, endIndex) || inputString[endIndex] != '"')
//				goto default;
//			currentToken.lineNumber = lineNumber;
//			currentToken.value = lexString(inputString, endIndex,
//				lineNumber, inputString[endIndex], false);
//			currentToken.type = TokenType.StringLiteral;
//			break;
//		case '`':
//			currentToken.lineNumber = lineNumber;
//			currentToken.value = lexString(inputString, endIndex, lineNumber,
//				inputString[endIndex], false);
//			currentToken.type = TokenType.StringLiteral;
//			break;
//		case 'x':
//			++endIndex;
//			if (isEoF(inputString, endIndex) || inputString[endIndex] != '"')
//				goto default;
//			else
//				goto case '"'; // BUG: this is incorrect! according to specification, hex data should be lexed differently than "normal" strings
//		case '\'':
//		case '"':
//			currentToken.lineNumber = lineNumber;
//			currentToken.value = lexString(inputString, endIndex, lineNumber,
//				inputString[endIndex]);
//			currentToken.type = TokenType.StringLiteral;
//			break;
//		case 'q':
//			currentToken.value = "q";
//			++endIndex;
//			if (!isEoF(inputString, endIndex))
//			{
//				switch (inputString[endIndex])
//				{
//					case '"':
//						currentToken.lineNumber = lineNumber;
//						currentToken.value ~= lexDelimitedString(inputString,
//							endIndex, lineNumber);
//						currentToken.type = TokenType.StringLiteral;
//						break outerSwitch;
//					case '{':
//						currentToken.lineNumber = lineNumber;
//						currentToken.value ~= lexTokenString(inputString,
//							endIndex, lineNumber);
//						currentToken.type = TokenType.StringLiteral;
//						break outerSwitch;
//					default:
//						break;
//				}
//			}
//			goto default;
//		case '@':
//			++endIndex;
//			goto default;
//		default:
//			while(!isEoF(inputString, endIndex) && !isSeparating(inputString[endIndex]))
//				++endIndex;
//			currentToken.value = inputString[startIndex .. endIndex];
//			currentToken.type = lookupTokenTypeOptimized(currentToken.value);
//			//currentToken.type = lookupTokenType(currentToken.value);
//			currentToken.lineNumber = lineNumber;
//			break;
//		}
//		//stderr.writeln(currentToken);
//		tokenAppender.put(currentToken);
//
//		// This should never happen.
//		if (endIndex <= prevIndex)
//		{
//			stderr.writeln("FAIL");
//			return [];
//		}
//	}
//	return tokenAppender.data;
//}