Mercurial > botc / changeset

--- a/CMakeLists.txt	Sun Mar 30 21:35:06 2014 +0300
+++ b/CMakeLists.txt	Sun Mar 30 21:51:23 2014 +0300
@@ -1,37 +1,37 @@
 cmake_minimum_required (VERSION 2.8)
 
 set (BOTC_HEADERS
-	src/BotStuff.h
-	src/Commands.h
-	src/Containers.h
-	src/DataBuffer.h
-	src/Events.h
-	src/Expression.h
-	src/Format.h
-	src/Lexer.h
-	src/LexerScanner.h
-	src/Macros.h
-	src/Main.h
-	src/Parser.h
-	src/Property.h
-	src/String.h
-	src/StringTable.h
-	src/Tokens.h
-	src/Types.h
+	src/botStuff.h
+	src/commands.h
+	src/list.h
+	src/dataBuffer.h
+	src/events.h
+	src/expression.h
+	src/format.h
+	src/lexer.h
+	src/lexerScanner.h
+	src/macros.h
+	src/main.h
+	src/parser.h
+	src/property.h
+	src/string.h
+	src/stringTable.h
+	src/tokens.h
+	src/types.h
 )
 
 set (BOTC_SOURCES
-	src/Commands.cc
-	src/DataBuffer.cc
-	src/Events.cc
-	src/Expression.cc
-	src/Format.cc
-	src/Lexer.cc
-	src/LexerScanner.cc
-	src/Main.cc
-	src/Parser.cc
-	src/String.cc
-	src/StringTable.cc
+	src/commands.cpp
+	src/dataBuffer.cpp
+	src/events.cpp
+	src/expression.cpp
+	src/format.cpp
+	src/lexer.cpp
+	src/lexerScanner.cpp
+	src/main.cpp
+	src/parser.cpp
+	src/string.cpp
+	src/stringTable.cpp
 )
 
 add_subdirectory (updaterevision)
@@ -40,14 +40,14 @@
 get_target_property (UPDATEREVISION_EXE updaterevision LOCATION)
 
 add_custom_target (revision_check ALL
-    COMMAND ${UPDATEREVISION_EXE} src/GitInformation.h
+    COMMAND ${UPDATEREVISION_EXE} src/gitinfo.h
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
     DEPENDS updaterevision)
 
 get_target_property (NAMEDENUMS_EXE namedenums LOCATION)
 
 add_custom_target (botc_enum_strings ALL
-    COMMAND ${NAMEDENUMS_EXE} ${BOTC_HEADERS} src/EnumStrings.h
+    COMMAND ${NAMEDENUMS_EXE} ${BOTC_HEADERS} src/enumStrings.h
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
     DEPENDS namedenums)
 
@@ -57,4 +57,4 @@
 
 if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
 	set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDEBUG")
-endif()
\ No newline at end of file
+endif()

--- a/namedenums/CMakeLists.txt	Sun Mar 30 21:35:06 2014 +0300
+++ b/namedenums/CMakeLists.txt	Sun Mar 30 21:51:23 2014 +0300
@@ -1,3 +1,3 @@
 cmake_minimum_required (VERSION 2.4)
-add_executable (namedenums NamedEnumerations.cc)
+add_executable (namedenums namedenums.cpp)
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -W -Wall")

--- a/namedenums/NamedEnumerations.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,251 +0,0 @@
-/*
-	Copyright 2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <string>
-#include <deque>
-#include <algorithm>
-#include <cerrno>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cstdarg>
-
-using std::string;
-using std::deque;
-
-static int gLineNumber;
-static std::string gCurrentFile;
-
-// =============================================================================
-//
-struct NamedEnumInfo
-{
-	string			name;
-	deque<string>	enumerators;
-};
-
-// =============================================================================
-//
-void SkipWhitespace (char*& cp)
-{
-	while (isspace (*cp))
-	{
-		if (*cp == '\n')
-			gLineNumber++;
-
-		++cp;
-	}
-
-	if (strncmp (cp, "//", 2) == 0)
-	{
-		while (*(++cp) != '\n')
-			;
-
-		gLineNumber++;
-		SkipWhitespace (cp);
-	}
-}
-
-// =============================================================================
-//
-void Error (const char* fmt, ...)
-{
-	char buf[1024];
-	va_list va;
-	va_start (va, fmt);
-	vsprintf (buf, fmt, va);
-	va_end (va);
-	throw std::string (buf);
-}
-
-// =============================================================================
-//
-int main (int argc, char* argv[])
-{
-	try
-	{
-		deque<NamedEnumInfo>	namedEnumerations;
-		deque<string>			filesToInclude;
-
-		if (argc < 3)
-		{
-			fprintf (stderr, "usage: %s input [input [input [...]]] output\n", argv[0]);
-			return EXIT_FAILURE;
-		}
-
-		for (int i = 1; i < argc - 1; ++ i)
-		{
-			gCurrentFile = argv[i];
-			FILE* fp = fopen (argv[i], "r");
-			char* buf;
-			gLineNumber = 1;
-
-			if (fp == NULL)
-			{
-				fprintf (stderr, "could not open %s for writing: %s\n",
-					argv[i], strerror (errno));
-				exit (EXIT_FAILURE);
-			}
-
-			fseek (fp, 0, SEEK_END);
-			long int filesize = ftell (fp);
-			rewind (fp);
-
-			try
-			{
-				buf = new char[filesize];
-			}
-			catch (std::bad_alloc)
-			{
-				Error ("could not allocate %ld bytes for %s\n", filesize, argv[i]);
-			}
-
-			if (static_cast<long> (fread (buf, 1, filesize, fp)) < filesize)
-				Error ("could not read %ld bytes from %s\n", filesize, argv[i]);
-
-			char* const end = &buf[0] + filesize;
-
-			for (char* cp = &buf[0]; cp < end; ++cp)
-			{
-				SkipWhitespace (cp);
-
-				if (strncmp (cp, "#define ", strlen ("#define ")) == 0)
-				{
-					while (cp < end && *cp != '\n')
-						cp++;
-
-					continue;
-				}
-
-				if ((cp != &buf[0] && isspace (* (cp - 1)) == false) ||
-					strncmp (cp, "named_enum ", strlen ("named_enum ")) != 0)
-				{
-					continue;
-				}
-
-				cp += strlen ("named_enum ");
-				SkipWhitespace (cp);
-
-				NamedEnumInfo nenum;
-				auto& enumname = nenum.name;
-				auto& enumerators = nenum.enumerators;
-
-				if (isalpha (*cp) == false && *cp != '_')
-					Error ("anonymous named_enum");
-
-				while (isalnum (*cp) || *cp == '_')
-					enumname += *cp++;
-
-				SkipWhitespace (cp);
-
-				if (*cp++ != '{')
-					Error ("expected '{' after named_enum");
-
-				for (;;)
-				{
-					SkipWhitespace (cp);
-
-					if (*cp == '}')
-					{
-						cp++;
-						break;
-					}
-
-					if (isalpha (*cp) == false && *cp != '_')
-						Error ("expected identifier, got '%c'", *cp);
-
-					std::string enumerator;
-
-					while (isalnum (*cp) || *cp == '_')
-						enumerator += *cp++;
-
-					SkipWhitespace (cp);
-
-					if (*cp == ',')
-						SkipWhitespace (++cp);
-
-					if (*cp == '=')
-						Error ("named enums must not have defined values");
-
-					enumerators.push_back (enumerator);
-				}
-
-				SkipWhitespace (cp);
-
-				if (*cp != ';')
-					Error ("expected ';'");
-
-				if (enumerators.size() > 0)
-				{
-					namedEnumerations.push_back (nenum);
-					filesToInclude.push_back (argv[i]);
-				}
-			}
-		}
-
-		FILE* fp;
-
-		if ((fp = fopen (argv[argc - 1], "w")) == NULL)
-			Error ("couldn't open %s for writing: %s", argv[argc - 1], strerror (errno));
-
-		fprintf (fp, "#pragma once\n");
-
-		std::sort (filesToInclude.begin(), filesToInclude.end());
-		auto pos = std::unique (filesToInclude.begin(), filesToInclude.end());
-		filesToInclude.resize (std::distance (filesToInclude.begin(), pos));
-
-		for (const string& a : filesToInclude)
-			fprintf (fp, "#include \"%s\"\n", basename (a.c_str()));
-
-		for (NamedEnumInfo& e : namedEnumerations)
-		{
-			fprintf (fp, "\nstatic const char* g_%sNames[] =\n{\n", e.name.c_str());
-
-			for (const string& a : e.enumerators)
-				fprintf (fp, "\t\"%s\",\n", a.c_str());
-
-			fprintf (fp, "};\n\n");
-
-			fprintf (fp, "inline const char* get%sString (%s a)\n"
-				"{\n"
-				"\treturn g_%sNames[a];\n"
-				"}\n",
-				e.name.c_str(), e.name.c_str(), e.name.c_str());
-		}
-
-		printf ("Wrote named enumerations to %s\n", argv[argc - 1]);
-		fclose (fp);
-	}
-	catch (std::string a)
-	{
-		fprintf (stderr, "%s:%d: error: %s\n", gCurrentFile.c_str(), gLineNumber, a.c_str());
-		return 1;
-	}
-
-	return 0;
-}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/namedenums/namedenums.cpp	Sun Mar 30 21:51:23 2014 +0300
@@ -0,0 +1,251 @@
+/*
+	Copyright 2014 Santeri Piippo
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions
+	are met:
+
+	1. Redistributions of source code must retain the above copyright
+	   notice, this list of conditions and the following disclaimer.
+	2. Redistributions in binary form must reproduce the above copyright
+	   notice, this list of conditions and the following disclaimer in the
+	   documentation and/or other materials provided with the distribution.
+	3. The name of the author may not be used to endorse or promote products
+	   derived from this software without specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <string>
+#include <deque>
+#include <algorithm>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cstdarg>
+
+using std::string;
+using std::deque;
+
+static int gLineNumber;
+static std::string gCurrentFile;
+
+// =============================================================================
+//
+struct NamedEnumInfo
+{
+	string			name;
+	deque<string>	enumerators;
+};
+
+// =============================================================================
+//
+void SkipWhitespace (char*& cp)
+{
+	while (isspace (*cp))
+	{
+		if (*cp == '\n')
+			gLineNumber++;
+
+		++cp;
+	}
+
+	if (strncmp (cp, "//", 2) == 0)
+	{
+		while (*(++cp) != '\n')
+			;
+
+		gLineNumber++;
+		SkipWhitespace (cp);
+	}
+}
+
+// =============================================================================
+//
+void Error (const char* fmt, ...)
+{
+	char buf[1024];
+	va_list va;
+	va_start (va, fmt);
+	vsprintf (buf, fmt, va);
+	va_end (va);
+	throw std::string (buf);
+}
+
+// =============================================================================
+//
+int main (int argc, char* argv[])
+{
+	try
+	{
+		deque<NamedEnumInfo>	namedEnumerations;
+		deque<string>			filesToInclude;
+
+		if (argc < 3)
+		{
+			fprintf (stderr, "usage: %s input [input [input [...]]] output\n", argv[0]);
+			return EXIT_FAILURE;
+		}
+
+		for (int i = 1; i < argc - 1; ++ i)
+		{
+			gCurrentFile = argv[i];
+			FILE* fp = fopen (argv[i], "r");
+			char* buf;
+			gLineNumber = 1;
+
+			if (fp == NULL)
+			{
+				fprintf (stderr, "could not open %s for writing: %s\n",
+					argv[i], strerror (errno));
+				exit (EXIT_FAILURE);
+			}
+
+			fseek (fp, 0, SEEK_END);
+			long int filesize = ftell (fp);
+			rewind (fp);
+
+			try
+			{
+				buf = new char[filesize];
+			}
+			catch (std::bad_alloc)
+			{
+				Error ("could not allocate %ld bytes for %s\n", filesize, argv[i]);
+			}
+
+			if (static_cast<long> (fread (buf, 1, filesize, fp)) < filesize)
+				Error ("could not read %ld bytes from %s\n", filesize, argv[i]);
+
+			char* const end = &buf[0] + filesize;
+
+			for (char* cp = &buf[0]; cp < end; ++cp)
+			{
+				SkipWhitespace (cp);
+
+				if (strncmp (cp, "#define ", strlen ("#define ")) == 0)
+				{
+					while (cp < end && *cp != '\n')
+						cp++;
+
+					continue;
+				}
+
+				if ((cp != &buf[0] && isspace (* (cp - 1)) == false) ||
+					strncmp (cp, "named_enum ", strlen ("named_enum ")) != 0)
+				{
+					continue;
+				}
+
+				cp += strlen ("named_enum ");
+				SkipWhitespace (cp);
+
+				NamedEnumInfo nenum;
+				auto& enumname = nenum.name;
+				auto& enumerators = nenum.enumerators;
+
+				if (isalpha (*cp) == false && *cp != '_')
+					Error ("anonymous named_enum");
+
+				while (isalnum (*cp) || *cp == '_')
+					enumname += *cp++;
+
+				SkipWhitespace (cp);
+
+				if (*cp++ != '{')
+					Error ("expected '{' after named_enum");
+
+				for (;;)
+				{
+					SkipWhitespace (cp);
+
+					if (*cp == '}')
+					{
+						cp++;
+						break;
+					}
+
+					if (isalpha (*cp) == false && *cp != '_')
+						Error ("expected identifier, got '%c'", *cp);
+
+					std::string enumerator;
+
+					while (isalnum (*cp) || *cp == '_')
+						enumerator += *cp++;
+
+					SkipWhitespace (cp);
+
+					if (*cp == ',')
+						SkipWhitespace (++cp);
+
+					if (*cp == '=')
+						Error ("named enums must not have defined values");
+
+					enumerators.push_back (enumerator);
+				}
+
+				SkipWhitespace (cp);
+
+				if (*cp != ';')
+					Error ("expected ';'");
+
+				if (enumerators.size() > 0)
+				{
+					namedEnumerations.push_back (nenum);
+					filesToInclude.push_back (argv[i]);
+				}
+			}
+		}
+
+		FILE* fp;
+
+		if ((fp = fopen (argv[argc - 1], "w")) == NULL)
+			Error ("couldn't open %s for writing: %s", argv[argc - 1], strerror (errno));
+
+		fprintf (fp, "#pragma once\n");
+
+		std::sort (filesToInclude.begin(), filesToInclude.end());
+		auto pos = std::unique (filesToInclude.begin(), filesToInclude.end());
+		filesToInclude.resize (std::distance (filesToInclude.begin(), pos));
+
+		for (const string& a : filesToInclude)
+			fprintf (fp, "#include \"%s\"\n", basename (a.c_str()));
+
+		for (NamedEnumInfo& e : namedEnumerations)
+		{
+			fprintf (fp, "\nstatic const char* g_%sNames[] =\n{\n", e.name.c_str());
+
+			for (const string& a : e.enumerators)
+				fprintf (fp, "\t\"%s\",\n", a.c_str());
+
+			fprintf (fp, "};\n\n");
+
+			fprintf (fp, "inline const char* get%sString (%s a)\n"
+				"{\n"
+				"\treturn g_%sNames[a];\n"
+				"}\n",
+				e.name.c_str(), e.name.c_str(), e.name.c_str());
+		}
+
+		printf ("Wrote named enumerations to %s\n", argv[argc - 1]);
+		fclose (fp);
+	}
+	catch (std::string a)
+	{
+		fprintf (stderr, "%s:%d: error: %s\n", gCurrentFile.c_str(), gLineNumber, a.c_str());
+		return 1;
+	}
+
+	return 0;
+}

--- a/src/BotStuff.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,125 +0,0 @@
-/*
-	Copyright 2000-2010 Brad Carney
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-// Numeric values and stuff from zandronum bots.h
-
-#ifndef BOTC_BOTSTUFF_H
-#define BOTC_BOTSTUFF_H
-
-#include "Main.h"
-
-static const int gMaxStates			= 256;
-static const int gMaxEvents			= 32;
-static const int gMaxGlobalEvents	= 32;
-static const int gMaxGlobalVars		= 128;
-static const int gMaxGlobalArrays	= 16;
-static const int gMaxArraySize		= 65536;
-static const int gMaxStateVars		= 16;
-static const int gMaxStringlistSize	= 128;
-static const int gMaxStringLength	= 256;
-static const int gMaxReactionTime	= 52;
-static const int gMaxStoredEvents	= 64;
-
-named_enum DataHeader
-{
-	DH_Command,
-	DH_StateIndex,
-	DH_StateName,
-	DH_OnEnter,
-	DH_MainLoop,
-	DH_OnExit,
-	DH_Event,
-	DH_EndOnEnter,
-	DH_EndMainLoop,
-	DH_EndOnExit,
-	DH_EndEvent,
-	DH_IfGoto,
-	DH_IfNotGoto,
-	DH_Goto,
-	DH_OrLogical,
-	DH_AndLogical,
-	DH_OrBitwise,
-	DH_EorBitwise,
-	DH_AndBitwise,
-	DH_Equals,
-	DH_NotEquals,
-	DH_LessThan,
-	DH_AtMost,
-	DH_GreaterThan,
-	DH_AtLeast,
-	DH_NegateLogical,
-	DH_LeftShift,
-	DH_RightShift,
-	DH_Add,
-	DH_Subtract,
-	DH_UnaryMinus,
-	DH_Multiply,
-	DH_Divide,
-	DH_Modulus,
-	DH_PushNumber,
-	DH_PushStringIndex,
-	DH_PushGlobalVar,
-	DH_PushLocalVar,
-	DH_DropStackPosition,
-	DH_ScriptVarList,
-	DH_StringList,
-	DH_IncreaseGlobalVar,
-	DH_DecreaseGlobalVar,
-	DH_AssignGlobalVar,
-	DH_AddGlobalVar,
-	DH_SubtractGlobalVar,
-	DH_MultiplyGlobalVar,
-	DH_DivideGlobalVar,
-	DH_ModGlobalVar,
-	DH_IncreaseLocalVar,
-	DH_DecreaseLocalVar,
-	DH_AssignLocalVar,
-	DH_AddLocalVar,
-	DH_SubtractLocalVar,
-	DH_MultiplyLocalVar,
-	DH_DivideLocalVar,
-	DH_ModLocalVar,
-	DH_CaseGoto,
-	DH_Drop,
-	DH_IncreaseGlobalArray,
-	DH_DecreaseGlobalArray,
-	DH_AssignGlobalArray,
-	DH_AddGlobalArray,
-	DH_SubtractGlobalArray,
-	DH_MultiplyGlobalArray,
-	DH_DivideGlobalArray,
-	DH_ModGlobalArray,
-	DH_PushGlobalArray,
-	DH_Swap,
-	DH_Dup,
-	DH_ArraySet,
-	numDataHeaders
-};
-
-#endif	// BOTC_BOTSTUFF_H

--- a/src/Commands.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,123 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "Main.h"
-#include "String.h"
-#include "Commands.h"
-#include "Lexer.h"
-
-static List<CommandInfo*> gCommands;
-
-// ============================================================================
-//
-void addCommandDefinition (CommandInfo* comm)
-{
-	// Ensure that there is no conflicts
-	for (CommandInfo* it : gCommands)
-		if (it->number == comm->number)
-			error ("Attempted to redefine command #%1 (%2) as %3",
-				   gCommands[comm->number]->name, comm->name);
-
-	gCommands << comm;
-}
-
-// ============================================================================
-// Finds a command by name
-CommandInfo* findCommandByName (String fname)
-{
-	for (CommandInfo* comm : gCommands)
-	{
-		if (fname.toUppercase() == comm->name.toUppercase())
-			return comm;
-	}
-
-	return null;
-}
-
-// ============================================================================
-//
-// Returns the prototype of the command
-//
-String CommandInfo::signature()
-{
-	String text;
-	text += dataTypeName (returnvalue);
-	text += ' ';
-	text += name;
-
-	if (args.isEmpty() == false)
-		text += ' ';
-
-	text += '(';
-
-	bool hasoptionals = false;
-
-	for (int i = 0; i < args.size(); i++)
-	{
-		if (i == minargs)
-		{
-			hasoptionals = true;
-			text += '[';
-		}
-
-		if (i)
-			text += ", ";
-
-		text += dataTypeName (args[i].type);
-		text += ' ';
-		text += args[i].name;
-
-		if (i >= minargs)
-		{
-			bool isString = args[i].type == TYPE_String;
-			text += " = ";
-
-			if (isString)
-				text += '"';
-
-			text += String::fromNumber (args[i].defvalue);
-
-			if (isString)
-				text += '"';
-		}
-	}
-
-	if (hasoptionals)
-		text += ']';
-
-	text += ')';
-	return text;
-}
-
-const List<CommandInfo*>& getCommands()
-{
-	return gCommands;
-}

--- a/src/Commands.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,58 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef BOTC_COMMANDS_H
-#define BOTC_COMMANDS_H
-
-#include "Main.h"
-#include "String.h"
-
-struct CommandArgument
-{
-	DataType				type;
-	String					name;
-	int						defvalue;
-};
-
-struct CommandInfo
-{
-	String					name;
-	int						number;
-	int						minargs;
-	DataType				returnvalue;
-	List<CommandArgument>	args;
-	String					origin;
-
-	String	signature();
-};
-
-void						addCommandDefinition (CommandInfo* comm);
-CommandInfo*				findCommandByName (String a);
-const List<CommandInfo*>&	getCommands();
-
-#endif // BOTC_COMMANDS_H

--- a/src/Containers.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,358 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef BOTC_CONTAINERS_H
-#define BOTC_CONTAINERS_H
-
-#include <cassert>
-#include <algorithm>
-#include <deque>
-#include <initializer_list>
-
-template<typename T>
-class List
-{
-	public:
-		using WrappedList				= typename std::deque<T>;
-		using Iterator					= typename WrappedList::iterator;
-		using ConstIterator				= typename WrappedList::const_iterator;
-		using ReverseIterator			= typename WrappedList::reverse_iterator;
-		using ConstReverseIterator		= typename WrappedList::const_reverse_iterator;
-		using ValueType					= T;
-		using Self						= List<T>;
-
-		// =====================================================================
-		//
-		List() {}
-
-		// =====================================================================
-		//
-		List (std::initializer_list<ValueType> vals)
-		{
-			m_data = vals;
-		}
-
-		// =====================================================================
-		//
-		List (const WrappedList& a) :
-			m_data (a) {}
-
-		// =====================================================================
-		//
-		Iterator begin()
-		{
-			return m_data.begin();
-		}
-
-		// =====================================================================
-		//
-		ConstIterator begin() const
-		{
-			return m_data.cbegin();
-		}
-
-		// =====================================================================
-		//
-		Iterator end()
-		{
-			return m_data.end();
-		}
-
-		// =====================================================================
-		//
-		ConstIterator end() const
-		{
-			return m_data.cend();
-		}
-
-		// =====================================================================
-		//
-		ReverseIterator rbegin()
-		{
-			return m_data.rbegin();
-		}
-
-		// =====================================================================
-		//
-		ConstReverseIterator crbegin() const
-		{
-			return m_data.crbegin();
-		}
-
-		// =====================================================================
-		//
-		ReverseIterator rend()
-		{
-			return m_data.rend();
-		}
-
-		// =====================================================================
-		//
-		ConstReverseIterator crend() const
-		{
-			return m_data.crend();
-		}
-
-		// =====================================================================
-		//
-		inline void removeAt (int pos)
-		{
-			assert (pos < size());
-			m_data.erase (m_data.begin() + pos);
-		}
-
-		// =====================================================================
-		//
-		ValueType& prepend (const ValueType& value)
-		{
-			m_data.push_front (value);
-			return m_data[0];
-		}
-
-		// =====================================================================
-		//
-		ValueType& append (const ValueType& value)
-		{
-			m_data.push_back (value);
-			return m_data[m_data.size() - 1];
-		}
-
-		// =====================================================================
-		//
-		void merge (const Self& other)
-		{
-			resize (size() + other.size());
-			std::copy (other.begin(), other.end(), begin() + other.size());
-		}
-
-		// =====================================================================
-		//
-		bool pop (T& val)
-		{
-			if (isEmpty())
-				return false;
-
-			val = m_data[size() - 1];
-			m_data.erase (m_data.end() - 1);
-			return true;
-		}
-
-		// =====================================================================
-		//
-		Self& operator<< (const T& value)
-		{
-			append (value);
-			return *this;
-		}
-
-		// =====================================================================
-		//
-		void operator<< (const Self& vals)
-		{
-			merge (vals);
-		}
-
-		// =====================================================================
-		//
-		bool operator>> (T& value)
-		{
-			return pop (value);
-		}
-
-		// =====================================================================
-		//
-		Self reverse() const
-		{
-			Self rev;
-
-			for (const T & val : *this)
-				val >> rev;
-
-			return rev;
-		}
-
-		// =====================================================================
-		//
-		void clear()
-		{
-			m_data.clear();
-		}
-
-		// =====================================================================
-		//
-		void insert (int pos, const ValueType& value)
-		{
-			m_data.insert (m_data.begin() + pos, value);
-		}
-
-		// =====================================================================
-		//
-		void removeDuplicates()
-		{
-			// Remove duplicate entries. For this to be effective, the vector must be
-			// sorted first.
-			sort();
-			Iterator pos = std::unique (begin(), end());
-			resize (std::distance (begin(), pos));
-		}
-
-		// =====================================================================
-		//
-		int size() const
-		{
-			return m_data.size();
-		}
-
-		// =====================================================================
-		//
-		ValueType& operator[] (int n)
-		{
-			assert (n < size());
-			return m_data[n];
-		}
-
-		// =====================================================================
-		//
-		const ValueType& operator[] (int n) const
-		{
-			assert (n < size());
-			return m_data[n];
-		}
-
-		// =====================================================================
-		//
-		void resize (int size)
-		{
-			m_data.resize (size);
-		}
-
-		// =====================================================================
-		//
-		void sort()
-		{
-			std::sort (begin(), end());
-		}
-
-		// =====================================================================
-		//
-		int find (const ValueType& needle) const
-		{
-			int i = 0;
-
-			for (const ValueType& hay : *this)
-			{
-				if (hay == needle)
-					return i;
-
-				i++;
-			}
-
-			return -1;
-		}
-
-		// =====================================================================
-		//
-		void removeOne (const ValueType& it)
-		{
-			int idx;
-
-			if ((idx = find (it)) != -1)
-				removeAt (idx);
-		}
-
-		// =====================================================================
-		//
-		inline bool isEmpty() const
-		{
-			return size() == 0;
-		}
-
-		// =====================================================================
-		//
-		Self splice (int a, int b) const
-		{
-			assert (a >= 0 && b >= 0 && a < size() && b < size() && a <= b);
-			Self result;
-
-			for (int i = a; i <= b; ++i)
-				result << operator[] (i);
-
-			return result;
-		}
-
-		// =====================================================================
-		//
-		inline const WrappedList& deque() const
-		{
-			return m_data;
-		}
-
-		// =====================================================================
-		//
-		inline const ValueType& first() const
-		{
-			return *m_data.begin();
-		}
-
-		// =====================================================================
-		//
-		inline const ValueType& last() const
-		{
-			return *(m_data.end() - 1);
-		}
-
-		// =====================================================================
-		//
-		inline bool contains (const ValueType& a) const
-		{
-			return find (a) != -1;
-		}
-
-		// =====================================================================
-		//
-		Self operator+ (const Self& other) const
-		{
-			Self out (*this);
-			out.merge (other);
-			return out;
-		}
-
-	private:
-		WrappedList m_data;
-};
-
-// =============================================================================
-//
-template<typename T>
-List<T>& operator>> (const T& value, List<T>& haystack)
-{
-	haystack.prepend (value);
-	return haystack;
-}
-
-#endif // BOTC_CONTAINERS_H

--- a/src/DataBuffer.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,242 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include "DataBuffer.h"
-
-// ============================================================================
-//
-DataBuffer::DataBuffer (int size)
-{
-	setBuffer (new char[size]);
-	setPosition (&buffer()[0]);
-	setAllocatedSize (size);
-}
-
-// ============================================================================
-//
-DataBuffer::~DataBuffer()
-{
-	assert (marks().isEmpty() && references().isEmpty());
-	delete buffer();
-}
-
-// ============================================================================
-//
-void DataBuffer::mergeAndDestroy (DataBuffer* other)
-{
-	if (other == null)
-		return;
-
-	// Note: We transfer the marks before the buffer is copied, so that the
-	// offset uses the proper value (which is the written size of @other, which
-	// we don't want our written size to be added to yet).
-	other->transferMarksTo (this);
-	copyBuffer (other);
-	delete other;
-}
-
-// ============================================================================
-//
-// Clones this databuffer to a new one and returns it. Note that the original
-// transfers its marks and references and loses them in the process.
-//
-DataBuffer* DataBuffer::clone()
-{
-	DataBuffer* other = new DataBuffer;
-	transferMarksTo (other);
-	other->copyBuffer (this);
-	return other;
-}
-
-// ============================================================================
-//
-void DataBuffer::copyBuffer (const DataBuffer* buf)
-{
-	checkSpace (buf->writtenSize());
-	memcpy (m_position, buf->buffer(), buf->writtenSize());
-	m_position += buf->writtenSize();
-}
-
-// ============================================================================
-//
-void DataBuffer::transferMarksTo (DataBuffer* dest)
-{
-	int offset = dest->writtenSize();
-
-	for (ByteMark* mark : marks())
-	{
-		mark->pos += offset;
-		dest->m_marks << mark;
-	}
-
-	for (MarkReference* ref : references())
-	{
-		ref->pos += offset;
-		dest->m_references << ref;
-	}
-
-	m_marks.clear();
-	m_references.clear();
-}
-
-// ============================================================================
-//
-ByteMark* DataBuffer::addMark (const String& name)
-{
-	ByteMark* mark = new ByteMark;
-	mark->name = name;
-	mark->pos = writtenSize();
-	m_marks << mark;
-	return mark;
-}
-
-// ============================================================================
-//
-MarkReference* DataBuffer::addReference (ByteMark* mark)
-{
-	MarkReference* ref = new MarkReference;
-	ref->target = mark;
-	ref->pos = writtenSize();
-	m_references << ref;
-
-	// Write a dummy placeholder for the reference
-	writeDWord (0xBEEFCAFE);
-
-	return ref;
-}
-
-// ============================================================================
-//
-void DataBuffer::adjustMark (ByteMark* mark)
-{
-	mark->pos = writtenSize();
-}
-
-// ============================================================================
-//
-void DataBuffer::offsetMark (ByteMark* mark, int position)
-{
-	mark->pos += position;
-}
-
-// ============================================================================
-//
-void DataBuffer::writeStringIndex (const String& a)
-{
-	writeDWord (DH_PushStringIndex);
-	writeDWord (getStringTableIndex (a));
-}
-
-// ============================================================================
-//
-void DataBuffer::dump()
-{
-	for (int i = 0; i < writtenSize(); ++i)
-		printf ("%d. [0x%X]\n", i, buffer()[i]);
-}
-
-// ============================================================================
-//
-void DataBuffer::checkSpace (int bytes)
-{
-	int writesize = writtenSize();
-
-	if (writesize + bytes < allocatedSize())
-		return;
-
-	// We don't have enough space in the buffer to write
-	// the stuff - thus resize. First, store the old
-	// buffer temporarily:
-	char* copy = new char[allocatedSize()];
-	memcpy (copy, buffer(), allocatedSize());
-
-	// Remake the buffer with the new size. Have enough space
-	// for the stuff we're going to write, as well as a bit
-	// of leeway so we don't have to resize immediately again.
-	int newsize = allocatedSize() + bytes + 512;
-
-	delete buffer();
-	setBuffer (new char[newsize]);
-	setAllocatedSize (newsize);
-
-	// Now, copy the stuff back.
-	memcpy (m_buffer, copy, allocatedSize());
-	setPosition (buffer() + writesize);
-	delete copy;
-}
-
-// =============================================================================
-//
-void DataBuffer::writeByte (int8_t data)
-{
-	checkSpace (1);
-	*m_position++ = data;
-}
-
-// =============================================================================
-//
-void DataBuffer::writeWord (int16_t data)
-{
-	checkSpace (2);
-
-	for (int i = 0; i < 2; ++i)
-		*m_position++ = (data >> (i * 8)) & 0xFF;
-}
-
-// =============================================================================
-//
-void DataBuffer::writeDWord (int32_t data)
-{
-	checkSpace (4);
-
-	for (int i = 0; i < 4; ++i)
-		*m_position++ = (data >> (i * 8)) & 0xFF;
-}
-
-// =============================================================================
-//
-void DataBuffer::writeString (const String& a)
-{
-	checkSpace (a.length() + 4);
-	writeDWord (a.length());
-
-	for (char c : a)
-		writeByte (c);
-}
-
-
-// =============================================================================
-//
-ByteMark* DataBuffer::findMarkByName (const String& name)
-{
-	for (ByteMark* mark : marks())
-		if (mark->name == name)
-			return mark;
-
-	return null;
-}

--- a/src/DataBuffer.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,157 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef BOTC_DATABUFFER_H
-#define BOTC_DATABUFFER_H
-
-#include <stdio.h>
-#include <string.h>
-#include "Main.h"
-#include "StringTable.h"
-
-/**
- *    @class DataBuffer
- *    @brief Stores a buffer of bytecode
- *
- *    The DataBuffer class stores a section of bytecode. Buffers are allocated on
- *    the heap and written to using the @c write* functions. Buffers can be cut and
- *    pasted together with @c mergeAndDestroy, note that this function destroys the
- *    parameter buffer in the process
- *
- *    A mark is a "pointer" to a particular position in the bytecode. The actual
- *    permanent position cannot be predicted in any way or form, thus these things
- *    are used to "bookmark" a position like that for future use.
- *
- *    A reference acts as a pointer to a mark. The reference is four bytes in the
- *    bytecode which will be replaced with its mark's position when the bytecode
- *    is written to the output file.
- *
- *    This mark/reference system is used to know bytecode offset values when
- *    compiling, even though actual final positions cannot be known.
- */
-class DataBuffer
-{
-	//! @
-	PROPERTY (private, char*,					buffer,			setBuffer,			STOCK_WRITE)
-	PROPERTY (private, int,						allocatedSize,	setAllocatedSize,	STOCK_WRITE)
-	PROPERTY (private, char*,					position,		setPosition,		STOCK_WRITE)
-	PROPERTY (private, List<ByteMark*>,			marks,			setMarks,			STOCK_WRITE)
-	PROPERTY (private, List<MarkReference*>,	references,		setReferences,		STOCK_WRITE)
-
-	public:
-		//! Constructs a new databuffer with @c size bytes.
-		DataBuffer (int size = 128);
-
-		//! Destructs the databuffer.
-		~DataBuffer();
-
-		//! Adds a new mark to the current position with the name @c name.
-		//! @param name the name of the new mark
-		//! @return a pointer to the new mark
-		ByteMark*		addMark (const String& name);
-
-		//! Adds a new reference to @c mark at the current position. This
-		//! function will write 4 bytes to the buffer whose value will
-		//! be determined at final output writing.
-		//! @param mark the mark which the new reference will attach to
-		//! @return a pointer to the new reference
-		MarkReference*	addReference (ByteMark* mark);
-
-		//! Moves @c mark to the current bytecode position.
-		//! @param mark the mark to adjust
-		void			adjustMark (ByteMark* mark);
-
-		//! Ensures there's at least @c bytes left in the buffer. Will resize
-		//! if necessary, no-op if not. On resize, 512 extra bytes are allocated
-		//! to reduce the amount of resizes.
-		//! @param bytes the amount of space in bytes to ensure allocated
-		void			checkSpace (int bytes);
-
-		//! Creates a clone of this data buffer.
-		//! @note All marks will be moved into the new databuffer as marks are
-		//! @note never duplicated.
-		//! @return The newly cloned databuffer.
-		DataBuffer*		clone();
-
-		//! Prints the buffer to stdout. Useful for debugging.
-		void			dump();
-
-		//! Finds the given mark by name.
-		//! @param name the name of the mark to find
-		ByteMark*		findMarkByName (const String& name);
-
-		//! Merge another data buffer into this one.
-		//! Note: @c other is destroyed in the process.
-		//! @param other the buffer to merge in
-		void			mergeAndDestroy (DataBuffer* other);
-
-		//! Moves @c mark to the given bytecode position.
-		//! @param mark the mark to adjust
-		//! @param position where to adjust the mark
-		void			offsetMark (ByteMark* mark, int position);
-
-		//! Transfers all marks of this buffer to @c other.
-		//! @param other the data buffer to transfer marks to
-		void			transferMarksTo (DataBuffer* other);
-
-		//! Writes the index of the given string to the databuffer.
-		//! 4 bytes will be written to the bytecode.
-		//! @param a the string whose index to write
-		void			writeStringIndex (const String& a);
-
-		//! Writes the given string as-is into the databuffer.
-		//! @c a.length + 4 bytes will be written to the buffer.
-		//! @param a the string to write
-		void			writeString (const String& a);
-
-		//! Writes the given byte to the buffer. 1 byte will be written.
-		//! @c data the byte to write
-		void			writeByte (int8_t data);
-
-		//! Writes the given word to the buffer. 2 byte will be written.
-		//! @c data the word to write
-		void			writeWord (int16_t data);
-
-		//! Writes the given double word to the buffer. 4 bytes will be written.
-		//! @c data the double word to write
-		void			writeDWord (int32_t data);
-
-		//! @return the amount of bytes written to this buffer.
-		inline int		writtenSize() const
-		{
-			return position() - buffer();
-		}
-
-	protected:
-		//! Writes the buffer's contents from @c buf.
-		//! @c buf.writtenSize() bytes will be written.
-		//! @param buf the buffer to copy
-		void			copyBuffer (const DataBuffer* buf);
-};
-
-#endif // BOTC_DATABUFFER_H

--- a/src/Events.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-// TODO: this file is a freeloader, I should probably get rid of it
-
-#include <stdlib.h>
-#include <stdio.h>
-#include "Main.h"
-#include "String.h"
-#include "Events.h"
-#include "Lexer.h"
-
-static List<EventDefinition*> g_Events;
-
-// ============================================================================
-//
-void addEvent (EventDefinition* e)
-{
-	g_Events << e;
-}
-
-// ============================================================================
-//
-// Finds an event definition by index
-//
-EventDefinition* findEventByIndex (int idx)
-{
-	return g_Events[idx];
-}
-
-// ============================================================================
-//
-// Finds an event definition by name
-//
-EventDefinition* findEventByName (String a)
-{
-	for (EventDefinition* e : g_Events)
-		if (a.toUppercase() == e->name.toUppercase())
-			return e;
-
-	return null;
-}

--- a/src/Events.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef BOTC_EVENTS_H
-#define BOTC_EVENTS_H
-
-#include "String.h"
-
-struct EventDefinition
-{
-	String name;
-	int number;
-};
-
-void addEvent (EventDefinition* e);
-EventDefinition* findEventByIndex (int idx);
-EventDefinition* findEventByName (String a);
-
-#endif // BOTC_EVENTS_H

--- a/src/Expression.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,651 +0,0 @@
-#include "Expression.h"
-#include "DataBuffer.h"
-#include "Lexer.h"
-
-struct OperatorInfo
-{
-	ETokenType	token;
-	int			priority;
-	int			numoperands;
-	DataHeader	header;
-};
-
-static const OperatorInfo g_Operators[] =
-{
-	{TK_ExclamationMark,	0,		1,	DH_NegateLogical,	},
-	{TK_Minus,				0,		1,	DH_UnaryMinus,		},
-	{TK_Multiply,			10,		2,	DH_Multiply,		},
-	{TK_Divide,				10,		2,	DH_Divide,			},
-	{TK_Modulus,			10,		2,	DH_Modulus,			},
-	{TK_Plus,				20,		2,	DH_Add,				},
-	{TK_Minus,				20,		2,	DH_Subtract,		},
-	{TK_LeftShift,			30,		2,	DH_LeftShift,		},
-	{TK_RightShift,			30,		2,	DH_RightShift,		},
-	{TK_Lesser,				40,		2,	DH_LessThan,		},
-	{TK_Greater,			40,		2,	DH_GreaterThan,		},
-	{TK_AtLeast,			40,		2,	DH_AtLeast,			},
-	{TK_AtMost,				40,		2,	DH_AtMost,			},
-	{TK_Equals,				50,		2,	DH_Equals			},
-	{TK_NotEquals,			50,		2,	DH_NotEquals		},
-	{TK_Amperstand,			60,		2,	DH_AndBitwise		},
-	{TK_Caret,				70,		2,	DH_EorBitwise		},
-	{TK_Bar,				80,		2,	DH_OrBitwise		},
-	{TK_DoubleAmperstand,	90,		2,	DH_AndLogical		},
-	{TK_DoubleBar,			100,	2,	DH_OrLogical		},
-	{TK_QuestionMark,		110,	3,	(DataHeader) 0		},
-};
-
-// =============================================================================
-//
-Expression::Expression (BotscriptParser* parser, Lexer* lx, DataType reqtype) :
-	m_parser (parser),
-	m_lexer (lx),
-	m_type (reqtype)
-{
-	ExpressionSymbol* sym;
-
-	while ((sym = parseSymbol()) != null)
-		m_symbols << sym;
-
-	// If we were unable to get any expression symbols, something's wonky with
-	// the script. Report an error. mBadTokenText is set to the token that
-	// ParseSymbol ends at when it returns false.
-	if (m_symbols.isEmpty())
-		error ("unknown identifier '%1'", m_badTokenText);
-
-	adjustOperators();
-	verify();
-	evaluate();
-}
-
-// =============================================================================
-//
-Expression::~Expression()
-{
-	for (ExpressionSymbol* sym : m_symbols)
-		delete sym;
-}
-
-// =============================================================================
-//
-// Try to parse an expression symbol (i.e. an OPER_erator or OPER_erand or a colon)
-// from the lexer.
-//
-ExpressionSymbol* Expression::parseSymbol()
-{
-	int pos = m_lexer->position();
-	ExpressionValue* op = null;
-
-	if (m_lexer->next (TK_Colon))
-		return new ExpressionColon;
-
-	// Check for OPER_erator
-	for (const OperatorInfo& op : g_Operators)
-		if (m_lexer->next (op.token))
-			return new ExpressionOperator ((ExpressionOperatorType) (&op - &g_Operators[0]));
-
-	// Check sub-expression
-	if (m_lexer->next (TK_ParenStart))
-	{
-		Expression expr (m_parser, m_lexer, m_type);
-		m_lexer->mustGetNext (TK_ParenEnd);
-		return expr.getResult()->clone();
-	}
-
-	op = new ExpressionValue (m_type);
-
-	// Check function
-	if (CommandInfo* comm = findCommandByName (m_lexer->peekNextString()))
-	{
-		m_lexer->skip();
-
-		if (m_type != TYPE_Unknown && comm->returnvalue != m_type)
-			error ("%1 returns an incompatible data type", comm->name);
-
-		op->setBuffer (m_parser->parseCommand (comm));
-		return op;
-	}
-
-	// Check for variables
-	if (m_lexer->next (TK_DollarSign))
-	{
-		m_lexer->mustGetNext (TK_Symbol);
-		Variable* var = m_parser->findVariable (getTokenString());
-
-		if (var == null)
-			error ("unknown variable %1", getTokenString());
-
-		if (var->type != m_type)
-			error ("expression requires %1, variable $%2 is of type %3",
-				dataTypeName (m_type), var->name, dataTypeName (var->type));
-
-		if (var->isarray)
-		{
-			m_lexer->mustGetNext (TK_BracketStart);
-			Expression expr (m_parser, m_lexer, TYPE_Int);
-			expr.getResult()->convertToBuffer();
-			DataBuffer* buf = expr.getResult()->buffer()->clone();
-			buf->writeDWord (DH_PushGlobalArray);
-			buf->writeDWord (var->index);
-			op->setBuffer (buf);
-			m_lexer->mustGetNext (TK_BracketEnd);
-		}
-		elif (var->writelevel == WRITE_Constexpr)
-			op->setValue (var->value);
-		else
-		{
-			DataBuffer* buf = new DataBuffer (8);
-
-			if (var->IsGlobal())
-				buf->writeDWord (DH_PushGlobalVar);
-			else
-				buf->writeDWord (DH_PushLocalVar);
-
-			buf->writeDWord (var->index);
-			op->setBuffer (buf);
-		}
-
-		return op;
-	}
-
-	// Check for literal
-	switch (m_type)
-	{
-		case TYPE_Void:
-		case TYPE_Unknown:
-		{
-			error ("unknown identifier `%1` (expected keyword, function or variable)", getTokenString());
-			break;
-		}
-
-		case TYPE_Bool:
-		{
-			if (m_lexer->next (TK_True) || m_lexer->next (TK_False))
-			{
-				ETokenType tt = m_lexer->tokenType();
-				op->setValue (tt == TK_True ? 1 : 0);
-				return op;
-			}
-		}
-
-		case TYPE_Int:
-		{
-			if (m_lexer->next (TK_Number))
-			{
-				op->setValue (getTokenString().toLong());
-				return op;
-			}
-		}
-
-		case TYPE_String:
-		{
-			if (m_lexer->next (TK_String))
-			{
-				op->setValue (getStringTableIndex (getTokenString()));
-				return op;
-			}
-		}
-	}
-
-	m_badTokenText = m_lexer->token()->text;
-	m_lexer->setPosition (pos);
-	delete op;
-	return null;
-}
-
-// =============================================================================
-//
-// The symbol parsing process only does token-based checking for OPER_erators.
-// Thus ALL minus OPER_erators are actually unary minuses simply because both
-// have TK_Minus as their token and the unary minus is prior to the binary minus
-// in the OPER_erator table. Now that we have all symbols present, we can
-// correct cases like this.
-//
-void Expression::adjustOperators()
-{
-	for (auto it = m_symbols.begin() + 1; it != m_symbols.end(); ++it)
-	{
-		if ((*it)->type() != EXPRSYM_Operator)
-			continue;
-
-		ExpressionOperator* op = static_cast<ExpressionOperator*> (*it);
-
-		// Unary minus with a value as the previous symbol cannot really be
-		// unary; replace with binary minus.
-		if (op->id() == OPER_UnaryMinus && (*(it - 1))->type() == EXPRSYM_Value)
-			op->setID (OPER_Subtraction);
-	}
-}
-
-// =============================================================================
-//
-// Verifies a single value. Helper function for Expression::verify.
-//
-void Expression::tryVerifyValue (bool* verified, SymbolList::Iterator it)
-{
-	// If it's an unary OPER_erator we skip to its value. The actual OPER_erator will
-	// be verified separately.
-	if ((*it)->type() == EXPRSYM_Operator &&
-			g_Operators[static_cast<ExpressionOperator*> (*it)->id()].numoperands == 1)
-	{
-		++it;
-	}
-
-	int i = it - m_symbols.begin();
-
-	// Ensure it's an actual value
-	if ((*it)->type() != EXPRSYM_Value)
-		error ("malformed expression (symbol #%1 is not a value)", i);
-
-	verified[i] = true;
-}
-
-// =============================================================================
-//
-// Ensures the expression is valid and well-formed and not OMGWTFBBQ. Throws an
-// error if this is not the case.
-//
-void Expression::verify()
-{
-	if (m_symbols.size() == 1)
-	{
-		if (m_symbols[0]->type() != EXPRSYM_Value)
-			error ("bad expression");
-
-		return;
-	}
-
-	if (m_type == TYPE_String)
-		error ("Cannot perform OPER_erations on strings");
-
-	bool* verified = new bool[m_symbols.size()];
-	memset (verified, 0, m_symbols.size() * sizeof (decltype (*verified)));
-	const auto last = m_symbols.end() - 1;
-	const auto first = m_symbols.begin();
-
-	for (auto it = m_symbols.begin(); it != m_symbols.end(); ++it)
-	{
-		int i = (it - first);
-
-		if ((*it)->type() != EXPRSYM_Operator)
-			continue;
-
-		ExpressionOperator* op = static_cast<ExpressionOperator*> (*it);
-		int numoperands = g_Operators[op->id()].numoperands;
-
-		switch (numoperands)
-		{
-			case 1:
-			{
-				// Ensure that:
-				// -	unary OPER_erator is not the last symbol
-				// -	unary OPER_erator is succeeded by a value symbol
-				// -	neither symbol overlaps with something already verified
-				tryVerifyValue (verified, it + 1);
-
-				if (it == last || verified[i] == true)
-					error ("malformed expression");
-
-				verified[i] = true;
-				break;
-			}
-
-			case 2:
-			{
-				// Ensure that:
-				// -	binary OPER_erator is not the first or last symbol
-				// -	is preceded and succeeded by values
-				// -	none of the three tokens are already verified
-				//
-				// Basically similar logic as above.
-				if (it == first || it == last || verified[i] == true)
-					error ("malformed expression");
-
-				tryVerifyValue (verified, it + 1);
-				tryVerifyValue (verified, it - 1);
-				verified[i] = true;
-				break;
-			}
-
-			case 3:
-			{
-				// Ternary OPER_erator case. This goes a bit nuts.
-				// This time we have the following:
-				//
-				// (VALUE) ? (VALUE) : (VALUE)
-				//         ^
-				// --------/ we are here
-				//
-				// Check that the:
-				// -	questionmark OPER_erator is not misplaced (first or last)
-				// -	the value behind the OPER_erator (-1) is valid
-				// -	the value after the OPER_erator (+1) is valid
-				// -	the value after the colon (+3) is valid
-				// -	none of the five tokens are verified
-				//
-				tryVerifyValue (verified, it - 1);
-				tryVerifyValue (verified, it + 1);
-				tryVerifyValue (verified, it + 3);
-
-				if (it == first ||
-					it >= m_symbols.end() - 3 ||
-					verified[i] == true ||
-					verified[i + 2] == true ||
-					(*(it + 2))->type() != EXPRSYM_Colon)
-				{
-					error ("malformed expression");
-				}
-
-				verified[i] = true;
-				verified[i + 2] = true;
-				break;
-			}
-
-			default:
-				error ("WTF OPER_erator with %1 OPER_erands", numoperands);
-		}
-	}
-
-	for (int i = 0; i < m_symbols.size(); ++i)
-		if (verified[i] == false)
-			error ("malformed expression: expr symbol #%1 is was left unverified", i);
-
-	delete verified;
-}
-
-
-// =============================================================================
-//
-// Which operator to evaluate?
-//
-Expression::SymbolList::Iterator Expression::findPrioritizedOperator()
-{
-	SymbolList::Iterator	best = m_symbols.end();
-	int						bestpriority = __INT_MAX__;
-
-	for (SymbolList::Iterator it = m_symbols.begin(); it != m_symbols.end(); ++it)
-	{
-		if ((*it)->type() != EXPRSYM_Operator)
-			continue;
-
-		ExpressionOperator* op = static_cast<ExpressionOperator*> (*it);
-		const OperatorInfo* info = &g_Operators[op->id()];
-
-		if (info->priority < bestpriority)
-		{
-			best = it;
-			bestpriority = info->priority;
-		}
-	}
-
-	return best;
-}
-
-// =============================================================================
-//
-// Process the given OPER_erator and values into a new value.
-//
-ExpressionValue* Expression::evaluateOperator (const ExpressionOperator* op,
-											   const List<ExpressionValue*>& values)
-{
-	const OperatorInfo* info = &g_Operators[op->id()];
-	bool isconstexpr = true;
-	assert (values.size() == info->numoperands);
-
-	for (ExpressionValue* val : values)
-	{
-		if (val->isConstexpr() == false)
-		{
-			isconstexpr = false;
-			break;
-		}
-	}
-
-	// If not all of the values are constant expressions, none of them shall be.
-	if (isconstexpr == false)
-		for (ExpressionValue* val : values)
-			val->convertToBuffer();
-
-	ExpressionValue* newval = new ExpressionValue (m_type);
-
-	if (isconstexpr == false)
-	{
-		// This is not a constant expression so we'll have to use databuffers
-		// to convey the expression to bytecode. Actual value cannot be evaluated
-		// until Zandronum processes it at run-time.
-		newval->setBuffer (new DataBuffer);
-
-		if (op->id() == OPER_Ternary)
-		{
-			// There isn't a dataheader for ternary OPER_erator. Instead, we use DH_IfNotGoto
-			// to create an "if-block" inside an expression.
-			// Behold, big block of writing madness! :P
-			//
-			DataBuffer* buf = newval->buffer();
-			DataBuffer* b0 = values[0]->buffer();
-			DataBuffer* b1 = values[1]->buffer();
-			DataBuffer* b2 = values[2]->buffer();
-			ByteMark* mark1 = buf->addMark (""); // start of "else" case
-			ByteMark* mark2 = buf->addMark (""); // end of expression
-			buf->mergeAndDestroy (b0);
-			buf->writeDWord (DH_IfNotGoto); // if the first OPER_erand (condition)
-			buf->addReference (mark1); // didn't eval true, jump into mark1
-			buf->mergeAndDestroy (b1); // otherwise, perform second OPER_erand (true case)
-			buf->writeDWord (DH_Goto); // afterwards, jump to the end, which is
-			buf->addReference (mark2); // marked by mark2.
-			buf->adjustMark (mark1); // move mark1 at the end of the true case
-			buf->mergeAndDestroy (b2); // perform third OPER_erand (false case)
-			buf->adjustMark (mark2); // move the ending mark2 here
-
-			for (int i = 0; i < 3; ++i)
-				values[i]->setBuffer (null);
-		}
-		else
-		{
-			// Generic case: write all arguments and apply the OPER_erator's
-			// data header.
-			for (ExpressionValue* val : values)
-			{
-				newval->buffer()->mergeAndDestroy (val->buffer());
-
-				// Null the pointer out so that the value's destructor will not
-				// attempt to double-free it.
-				val->setBuffer (null);
-			}
-
-			newval->buffer()->writeDWord (info->header);
-		}
-	}
-	else
-	{
-		// We have a constant expression. We know all the values involved and
-		// can thus compute the result of this expression on compile-time.
-		List<int> nums;
-		int a;
-
-		for (ExpressionValue* val : values)
-			nums << val->value();
-
-		switch (op->id())
-		{
-			case OPER_Addition:				a = nums[0] + nums[1];					break;
-			case OPER_Subtraction:			a = nums[0] - nums[1];					break;
-			case OPER_Multiplication:		a = nums[0] * nums[1];					break;
-			case OPER_UnaryMinus:			a = -nums[0];							break;
-			case OPER_NegateLogical:		a = !nums[0];							break;
-			case OPER_LeftShift:			a = nums[0] << nums[1];					break;
-			case OPER_RightShift:			a = nums[0] >> nums[1];					break;
-			case OPER_CompareLesser:		a = (nums[0] < nums[1]) ? 1 : 0;		break;
-			case OPER_CompareGreater:		a = (nums[0] > nums[1]) ? 1 : 0;		break;
-			case OPER_CompareAtLeast:		a = (nums[0] <= nums[1]) ? 1 : 0;		break;
-			case OPER_CompareAtMost:		a = (nums[0] >= nums[1]) ? 1 : 0;		break;
-			case OPER_CompareEquals:		a = (nums[0] == nums[1]) ? 1 : 0;		break;
-			case OPER_CompareNotEquals:		a = (nums[0] != nums[1]) ? 1 : 0;		break;
-			case OPER_BitwiseAnd:			a = nums[0] & nums[1];					break;
-			case OPER_BitwiseOr:			a = nums[0] | nums[1];					break;
-			case OPER_BitwiseXOr:			a = nums[0] ^ nums[1];					break;
-			case OPER_LogicalAnd:			a = (nums[0] && nums[1]) ? 1 : 0;		break;
-			case OPER_LogicalOr:			a = (nums[0] || nums[1]) ? 1 : 0;		break;
-			case OPER_Ternary:				a = (nums[0] != 0) ? nums[1] : nums[2];	break;
-
-			case OPER_Division:
-			{
-				if (nums[1] == 0)
-					error ("division by zero in constant expression");
-
-				a = nums[0] / nums[1];
-				break;
-			}
-
-			case OPER_Modulus:
-			{
-				if (nums[1] == 0)
-					error ("modulus by zero in constant expression");
-
-				a = nums[0] % nums[1];
-				break;
-			}
-		}
-
-		newval->setValue (a);
-	}
-
-	// The new value has been generated. We don't need the old stuff anymore.
-	for (ExpressionValue* val : values)
-		delete val;
-
-	delete op;
-	return newval;
-}
-
-// =============================================================================
-//
-ExpressionValue* Expression::evaluate()
-{
-	SymbolList::Iterator it;
-
-	while ((it = findPrioritizedOperator()) != m_symbols.end())
-	{
-		int i = it - m_symbols.begin();
-		List<SymbolList::Iterator> OPER_erands;
-		ExpressionOperator* op = static_cast<ExpressionOperator*> (*it);
-		const OperatorInfo* info = &g_Operators[op->id()];
-		int lower, upper; // Boundaries of area to replace
-
-		switch (info->numoperands)
-		{
-			case 1:
-			{
-				lower = i;
-				upper = i + 1;
-				OPER_erands << it + 1;
-				break;
-			}
-
-			case 2:
-			{
-				lower = i - 1;
-				upper = i + 1;
-				OPER_erands << it - 1
-				         << it + 1;
-				break;
-			}
-
-			case 3:
-			{
-				lower = i - 1;
-				upper = i + 3;
-				OPER_erands << it - 1
-				         << it + 1
-				         << it + 3;
-				break;
-			}
-
-			default:
-				assert (false);
-		}
-
-		List<ExpressionValue*> values;
-
-		for (auto it : OPER_erands)
-			values << static_cast<ExpressionValue*> (*it);
-
-		// Note: @op and all of @values are invalid after this call.
-		ExpressionValue* newvalue = evaluateOperator (op, values);
-
-		for (int i = upper; i >= lower; --i)
-			m_symbols.removeAt (i);
-
-		m_symbols.insert (lower, newvalue);
-	}
-
-	assert (m_symbols.size() == 1 && m_symbols.first()->type() == EXPRSYM_Value);
-	ExpressionValue* val = static_cast<ExpressionValue*> (m_symbols.first());
-	return val;
-}
-
-// =============================================================================
-//
-ExpressionValue* Expression::getResult()
-{
-	return static_cast<ExpressionValue*> (m_symbols.first());
-}
-
-// =============================================================================
-//
-String Expression::getTokenString()
-{
-	return m_lexer->token()->text;
-}
-
-// =============================================================================
-//
-ExpressionOperator::ExpressionOperator (ExpressionOperatorType id) :
-	ExpressionSymbol (EXPRSYM_Operator),
-	m_id (id) {}
-
-// =============================================================================
-//
-ExpressionValue::ExpressionValue (DataType valuetype) :
-	ExpressionSymbol (EXPRSYM_Value),
-	m_buffer (null),
-	m_valueType (valuetype) {}
-
-// =============================================================================
-//
-ExpressionValue::~ExpressionValue()
-{
-	delete m_buffer;
-}
-
-// =============================================================================
-//
-void ExpressionValue::convertToBuffer()
-{
-	if (isConstexpr() == false)
-		return;
-
-	setBuffer (new DataBuffer);
-
-	switch (m_valueType)
-	{
-		case TYPE_Bool:
-		case TYPE_Int:
-			buffer()->writeDWord (DH_PushNumber);
-			buffer()->writeDWord (abs (value()));
-
-			if (value() < 0)
-				buffer()->writeDWord (DH_UnaryMinus);
-			break;
-
-		case TYPE_String:
-			buffer()->writeDWord (DH_PushStringIndex);
-			buffer()->writeDWord (value());
-			break;
-
-		case TYPE_Void:
-		case TYPE_Unknown:
-			assert (false);
-			break;
-	}
-}

--- a/src/Expression.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,132 +0,0 @@
-#ifndef BOTC_EXPRESSION_H
-#define BOTC_EXPRESSION_H
-#include "Parser.h"
-
-class DataBuffer;
-class ExpressionSymbol;
-class ExpressionValue;
-class ExpressionOperator;
-
-// =============================================================================
-//
-named_enum ExpressionOperatorType
-{
-	OPER_NegateLogical,
-	OPER_UnaryMinus,
-	OPER_Multiplication,
-	OPER_Division,
-	OPER_Modulus,
-	OPER_Addition,
-	OPER_Subtraction,
-	OPER_LeftShift,
-	OPER_RightShift,
-	OPER_CompareLesser,
-	OPER_CompareGreater,
-	OPER_CompareAtLeast,
-	OPER_CompareAtMost,
-	OPER_CompareEquals,
-	OPER_CompareNotEquals,
-	OPER_BitwiseAnd,
-	OPER_BitwiseXOr,
-	OPER_BitwiseOr,
-	OPER_LogicalAnd,
-	OPER_LogicalOr,
-	OPER_Ternary,
-};
-
-// =============================================================================
-//
-enum ExpressionSymbolType
-{
-	EXPRSYM_Operator,
-	EXPRSYM_Value,
-	EXPRSYM_Colon,
-};
-
-class Expression final
-{
-	public:
-		using SymbolList = List<ExpressionSymbol*>;
-
-		Expression (BotscriptParser* parser, Lexer* lx, DataType reqtype);
-		~Expression();
-		ExpressionValue*		getResult();
-
-	private:
-		BotscriptParser*		m_parser;
-		Lexer*					m_lexer;
-		SymbolList				m_symbols;
-		DataType				m_type;
-		String					m_badTokenText;
-
-		ExpressionValue*		evaluate(); // Process the expression and yield a result
-		ExpressionSymbol*		parseSymbol();
-		String					getTokenString();
-		void					adjustOperators();
-		void					verify(); // Ensure the expr is valid
-		void					tryVerifyValue (bool* verified, SymbolList::Iterator it);
-		ExpressionValue*		evaluateOperator (const ExpressionOperator* op,
-												  const List<ExpressionValue*>& values);
-		SymbolList::Iterator	findPrioritizedOperator();
-};
-
-// =============================================================================
-//
-class ExpressionSymbol
-{
-	public:
-		ExpressionSymbol (ExpressionSymbolType type) :
-			m_type (type) {}
-
-	PROPERTY (private, ExpressionSymbolType, type, setType, STOCK_WRITE)
-};
-
-// =============================================================================
-//
-class ExpressionOperator final : public ExpressionSymbol
-{
-	PROPERTY (public, ExpressionOperatorType, id, setID, STOCK_WRITE)
-
-	public:
-		ExpressionOperator (ExpressionOperatorType id);
-};
-
-// =============================================================================
-//
-class ExpressionValue final : public ExpressionSymbol
-{
-	PROPERTY (public, int,			value,		setValue,		STOCK_WRITE)
-	PROPERTY (public, DataBuffer*,	buffer,		setBuffer,		STOCK_WRITE)
-	PROPERTY (public, DataType,		valueType,	setValueType,	STOCK_WRITE)
-
-	public:
-		ExpressionValue (DataType valuetype);
-		~ExpressionValue();
-
-		void					convertToBuffer();
-
-		inline ExpressionValue* clone() const
-		{
-			return new ExpressionValue (*this);
-		}
-
-		inline bool isConstexpr() const
-		{
-			return buffer() == null;
-		}
-};
-
-// =============================================================================
-//
-// This class represents a ":" in the expression. It serves as the colon for the
-// ternary ?: OPER_erator. It's not an OPER_erand nor is an OPER_erator, nor can we just
-// skip it so it is its own thing here.
-//
-class ExpressionColon final : public ExpressionSymbol
-{
-	public:
-		ExpressionColon() :
-			ExpressionSymbol (EXPRSYM_Colon) {}
-};
-
-#endif // BOTC_EXPRESSION_H

--- a/src/Format.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,116 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <cstdio>
-#include "Main.h"
-#include "Format.h"
-#include "Lexer.h"
-
-// =============================================================================
-//
-static void formatError (String fmtstr, const String errdescribe, int pos)
-{
-	fmtstr.replace ("\n", " ");
-	fmtstr.replace ("\t", " ");
-	String errmsg ("With format string:\n" + fmtstr + "\n");
-
-	for (int x = 0; x < pos; ++x)
-		errmsg += "-";
-
-	errmsg += "^\n" + errdescribe;
-	throw std::logic_error (errmsg.stdString());
-}
-
-// =============================================================================
-//
-String formatArgs (const String& fmtstr, const std::vector<String>& args)
-{
-	String fmt = fmtstr;
-	String out;
-	int pos = 0;
-
-	while ((pos = fmt.firstIndexOf ("%", pos)) != -1)
-	{
-		if (fmt[pos + 1] == '%')
-		{
-			fmt.replace (pos, 2, "%");
-			pos++;
-			continue;
-		}
-
-		int ofs = 1;
-		char mod = '\0';
-
-		// handle modifiers
-		if (fmt[pos + ofs] == 's' || fmt[pos + ofs] == 'x' || fmt[pos + ofs] == 'd')
-		{
-			mod = fmt[pos + ofs];
-			ofs++;
-		}
-
-		if (!isdigit (fmt[pos + ofs]))
-			formatError (fmtstr, "bad format string, expected digit with optional "
-				"modifier after '%%'", pos);
-
-		int i = fmt[pos + ofs]  - '0';
-
-		if (i > static_cast<signed> (args.size()))
-			formatError (fmtstr, String ("Format argument #") + i + " used but not defined.", pos);
-
-		String replacement = args[i - 1];
-
-		switch (mod)
-		{
-			case 's': replacement = (replacement == "1") ? "" : "s";		break;
-			case 'd': replacement.sprintf ("%d", replacement[0]);			break;
-			case 'x': replacement.sprintf ("0x%X", replacement.toLong());	break;
-			default: break;
-		}
-
-		fmt.replace (pos, 1 + ofs, replacement);
-		pos += replacement.length();
-	}
-
-	return fmt;
-}
-
-// =============================================================================
-//
-void error (String msg)
-{
-	Lexer* lx = Lexer::getCurrentLexer();
-	String fileinfo;
-
-	if (lx != null && lx->hasValidToken())
-	{
-		Lexer::TokenInfo* tk = lx->token();
-		fileinfo = format ("%1:%2:%3: ", tk->file, tk->line, tk->column);
-	}
-
-	throw std::runtime_error (fileinfo + msg);
-}

--- a/src/Format.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,231 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef BOTC_FORMAT_H
-#define BOTC_FORMAT_H
-
-#include "String.h"
-#include "Containers.h"
-
-class FormatArgument
-{
-	public:
-		FormatArgument (const String& a) : m_text (a) {}
-		FormatArgument (char a) : m_text (a) {}
-		FormatArgument (int a) : m_text (String::fromNumber (a)) {}
-		FormatArgument (long a) : m_text (String::fromNumber (a)) {}
-		FormatArgument (const char* a) : m_text (a) {}
-
-		FormatArgument (void* a)
-		{
-			m_text.sprintf ("%p", a);
-		}
-
-		FormatArgument (const void* a)
-		{
-			m_text.sprintf ("%p", a);
-		}
-
-		template<class T> FormatArgument (const List<T>& list)
-		{
-			if (list.isEmpty())
-			{
-				m_text = "{}";
-				return;
-			}
-
-			m_text = "{ ";
-
-			for (const T& a : list)
-			{
-				if (&a != &list[0])
-					m_text += ", ";
-
-				m_text += FormatArgument (a).text();
-			}
-
-			m_text += " }";
-		}
-
-		inline const String& text() const
-		{
-			return m_text;
-		}
-
-	private:
-		String m_text;
-};
-
-#ifndef IN_IDE_PARSER
-# ifdef DEBUG
-#  define devf(...) PrintTo (stderr, __VA_ARGS__)
-#  define dvalof( A ) PrintTo (stderr, "value of '%1' = %2\n", #A, A)
-# else
-#  define devf(...)
-#  define dvalof( A )
-# endif // DEBUG
-#else
-// print something in debug builds
-void devf (void, ...);
-
-// print the value of @a
-void dvalof (void a);
-#endif // IN_IDE_PARSER
-
-
-/**
- * Formats the given string with the given args.
- *
- * @param fmtstr Formatter string to process.
- * @param args Args to format with the string.
- * @see format()
- */
-String formatArgs (const String& fmtstr, const std::vector<String>& args);
-
-/**
- * Expands the given arguments into a vector of strings.
- *
- * @param data Where to insert the strings.
- * @param arg First argument to process
- * @param rest... Rest of the arguments.
- */
-template<typename T, typename... RestTypes>
-void expandFormatArguments (std::vector<String>& data, const T& arg, const RestTypes& ... rest)
-{
-	data.push_back (FormatArgument (arg).text());
-	expandFormatArguments (data, rest...);
-}
-
-/**
- * This is an overload of @c ExpandFormatArguments for end-of-args support.
- */
-static void expandFormatArguments (std::vector<String>& data) __attribute__ ( (unused));
-static void expandFormatArguments (std::vector<String>& data)
-{
-	(void) data;
-}
-
-/**
- * Formats the given formatter string and args and returns the string.
- * This is essentially a modernized sprintf.
- *
- * Args in the format string take the form %n where n is a digit. The argument
- * will be expanded to the nth argument passed. This is essentially Qt's
- * QString::arg() syntax. Note: %0 is invalid.
- *
- * Arguments can be passed a modifier which takes the form of a character
- * just before the digit. Currently supported modifiers are s, d and x.
- *
- * - s: The argument will expand into "s" if it would've not expanded into "1"
- *      otherwise. If it would have expanded into "1" it will expand into an
- *      empty string.
- *
- * - d: The argument expands into the numeric form of the first character of
- *      its previous expansion. Use this to get numeric forms of @c char
- *      arguments.
- *
- * - x: The numeric argument will be represented in hexadecimal notation. This
- *      will work if the argument is a string representing a number. If the
- *      argument did not expand into a number in the first place, 0 is used
- *      (and 0x0 is printed).
- *
- * @param fmtstr Formatter string to process
- * @param raw_args Arguments for the formatter string.
- * @return the formatted string.
- * @see Print
- * @see PrintTo
- */
-template<typename... argtypes>
-String format (const String& fmtstr, const argtypes&... raw_args)
-{
-	std::vector<String> args;
-	expandFormatArguments (args, raw_args...);
-	assert (args.size() == sizeof... (raw_args));
-	return formatArgs (fmtstr, args);
-}
-
-/**
- * This is an overload of @c format where no arguments are supplied.
- * @return the formatter string as-is.
- */
-static String format (const String& fmtstr) __attribute__ ( (unused));
-static String format (const String& fmtstr)
-{
-	return fmtstr;
-}
-
-/**
- * Processes the given formatter string using @c format and prints it to the
- * specified file pointer.
- *
- * @param fp File pointer to print the formatted string to
- * @param fmtstr Formatter string for @c format
- * @param args Arguments for @c fmtstr
- */
-template<typename... argtypes>
-void printTo (FILE* fp, const String& fmtstr, const argtypes&... args)
-{
-	fprintf (fp, "%s", format (fmtstr, args...).c_str());
-}
-
-/**
- * Processes the given formatter string using @c format and prints the result to
- * @c stdout.
- *
- * @param fmtstr Formatter string for @c format
- * @param args Arguments for @c fmtstr
- */
-template<typename... argtypes>
-void print (const String& fmtstr, const argtypes&... args)
-{
-	printTo (stdout, fmtstr, args...);
-}
-
-/**
- * Throws an std::runtime_error with the processed formatted string. The program
- * execution terminates after a call to this function as the exception is first
- * caught in @c main which prints the error to stderr and then exits.
- *
- * @param fmtstr The formatter string of the error.
- * @param args The args to the formatter string.
- * @see Format
- */
-template<typename... argtypes>
-void error (const String& fmtstr, const argtypes&... args)
-{
-	error (format (fmtstr, args...));
-}
-
-/**
- * An overload of @c Error with no string formatting in between.
- *
- * @param msg The error message.
- */
-void error (String msg);
-
-#endif // BOTC_FORMAT_H

--- a/src/Lexer.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,344 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <cstring>
-#include "Lexer.h"
-
-static StringList	gFileNameStack;
-static Lexer*		gMainLexer = null;
-
-// =============================================================================
-//
-Lexer::Lexer()
-{
-	assert (gMainLexer == null);
-	gMainLexer = this;
-}
-
-// =============================================================================
-//
-Lexer::~Lexer()
-{
-	gMainLexer = null;
-}
-
-// =============================================================================
-//
-void Lexer::processFile (String fileName)
-{
-	gFileNameStack << fileName;
-	FILE* fp = fopen (fileName, "r");
-
-	if (fp == null)
-		error ("couldn't open %1 for reading: %2", fileName, strerror (errno));
-
-	LexerScanner sc (fp);
-	checkFileHeader (sc);
-
-	while (sc.getNextToken())
-	{
-		// Preprocessor commands:
-		if (sc.getTokenType() ==TK_Hash)
-		{
-			mustGetFromScanner (sc,TK_Symbol);
-
-			if (sc.getTokenText() == "include")
-			{
-				mustGetFromScanner (sc,TK_String);
-				String fileName = sc.getTokenText();
-
-				if (gFileNameStack.contains (fileName))
-					error ("attempted to #include %1 recursively", sc.getTokenText());
-
-				processFile (fileName);
-			}
-			else
-				error ("unknown preprocessor directive \"#%1\"", sc.getTokenText());
-		}
-		else
-		{
-			TokenInfo tok;
-			tok.file = fileName;
-			tok.line = sc.getLine();
-			tok.column = sc.getColumn();
-			tok.type = sc.getTokenType();
-			tok.text = sc.getTokenText();
-
-			// devf ("Token #%1: %2:%3:%4: %5 (%6)\n", mTokens.size(),
-			// 	tok.file, tok.line, tok.column, DescribeToken (&tok),
-			// 	GetTokenTypeString (tok.type));
-
-			m_tokens << tok;
-		}
-	}
-
-	m_tokenPosition = m_tokens.begin() - 1;
-	gFileNameStack.removeOne (fileName);
-}
-
-// ============================================================================
-//
-static bool IsValidHeader (String header)
-{
-	if (header.endsWith ("\n"))
-		header.removeFromEnd (1);
-
-	StringList tokens = header.split (" ");
-
-	if (tokens.size() != 2 || tokens[0] != "#!botc" || tokens[1].isEmpty())
-		return false;
-
-	StringList nums = tokens[1].split (".");
-
-	if (nums.size() == 2)
-		nums << "0";
-	elif (nums.size() != 3)
-		return false;
-
-	bool okA, okB, okC;
-	long major = nums[0].toLong (&okA);
-	long minor = nums[1].toLong (&okB);
-	long patch = nums[2].toLong (&okC);
-
-	if (!okA || !okB || !okC)
-		return false;
-
-	if (VERSION_NUMBER < MAKE_VERSION_NUMBER (major, minor, patch))
-		error ("The script file requires " APPNAME " v%1, this is v%2",
-			makeVersionString (major, minor, patch), versionString (false));
-
-	return true;
-}
-
-// ============================================================================
-//
-void Lexer::checkFileHeader (LexerScanner& sc)
-{
-	if (!IsValidHeader (sc.readLine()))
-		error ("Not a valid botscript file! File must start with '#!botc <version>'");
-}
-
-// =============================================================================
-//
-bool Lexer::next (ETokenType req)
-{
-	Iterator pos = m_tokenPosition;
-
-	if (m_tokens.isEmpty())
-		return false;
-
-	m_tokenPosition++;
-
-	if (isAtEnd() || (req !=TK_Any && tokenType() != req))
-	{
-		m_tokenPosition = pos;
-		return false;
-	}
-
-	return true;
-}
-
-// =============================================================================
-//
-void Lexer::mustGetNext (ETokenType tok)
-{
-	if (!next())
-		error ("unexpected EOF");
-
-	if (tok !=TK_Any)
-		tokenMustBe (tok);
-}
-
-// =============================================================================
-// eugh..
-//
-void Lexer::mustGetFromScanner (LexerScanner& sc, ETokenType tt)
-{
-	if (sc.getNextToken() == false)
-		error ("unexpected EOF");
-
-	if (tt != TK_Any && sc.getTokenType() != tt)
-	{
-		// TODO
-		TokenInfo tok;
-		tok.type = sc.getTokenType();
-		tok.text = sc.getTokenText();
-
-		error ("at %1:%2: expected %3, got %4",
-			gFileNameStack.last(),
-			sc.getLine(),
-			describeTokenType (tt),
-			describeToken (&tok));
-	}
-}
-
-// =============================================================================
-//
-void Lexer::mustGetAnyOf (const List<ETokenType>& toks)
-{
-	if (!next())
-		error ("unexpected EOF");
-
-	for (ETokenType tok : toks)
-		if (tokenType() == tok)
-			return;
-
-	String toknames;
-
-	for (const ETokenType& tokType : toks)
-	{
-		if (&tokType == &toks.last())
-			toknames += " or ";
-		elif (toknames.isEmpty() == false)
-			toknames += ", ";
-
-		toknames += describeTokenType (tokType);
-	}
-
-	error ("expected %1, got %2", toknames, describeToken (token()));
-}
-
-// =============================================================================
-//
-int Lexer::getOneSymbol (const StringList& syms)
-{
-	if (!next())
-		error ("unexpected EOF");
-
-	if (tokenType() ==TK_Symbol)
-	{
-		for (int i = 0; i < syms.size(); ++i)
-		{
-			if (syms[i] == token()->text)
-				return i;
-		}
-	}
-
-	error ("expected one of %1, got %2", syms, describeToken (token()));
-	return -1;
-}
-
-// =============================================================================
-//
-void Lexer::tokenMustBe (ETokenType tok)
-{
-	if (tokenType() != tok)
-		error ("expected %1, got %2", describeTokenType (tok),
-			describeToken (token()));
-}
-
-// =============================================================================
-//
-String Lexer::describeTokenPrivate (ETokenType tokType, Lexer::TokenInfo* tok)
-{
-	if (tokType <gLastNamedToken)
-		return "\"" + LexerScanner::getTokenString (tokType) + "\"";
-
-	switch (tokType)
-	{
-		case TK_Symbol:	return tok ? tok->text : "a symbol";
-		case TK_Number:	return tok ? tok->text : "a number";
-		case TK_String:	return tok ? ("\"" + tok->text + "\"") : "a string";
-		case TK_Any:	return tok ? tok->text : "any token";
-		default: break;
-	}
-
-	return "";
-}
-
-// =============================================================================
-//
-bool Lexer::peekNext (Lexer::TokenInfo* tk)
-{
-	Iterator pos = m_tokenPosition;
-	bool r = next();
-
-	if (r && tk != null)
-		*tk = *m_tokenPosition;
-
-	m_tokenPosition = pos;
-	return r;
-}
-
-// =============================================================================
-//
-bool Lexer::peekNextType (ETokenType req)
-{
-	Iterator pos = m_tokenPosition;
-	bool result = false;
-
-	if (next() && tokenType() == req)
-		result = true;
-
-	m_tokenPosition = pos;
-	return result;
-}
-
-// =============================================================================
-//
-Lexer* Lexer::getCurrentLexer()
-{
-	return gMainLexer;
-}
-
-// =============================================================================
-//
-String Lexer::peekNextString (int a)
-{
-	if (m_tokenPosition + a >= m_tokens.end())
-		return "";
-
-	Iterator oldpos = m_tokenPosition;
-	m_tokenPosition += a;
-	String result = token()->text;
-	m_tokenPosition = oldpos;
-	return result;
-}
-
-// =============================================================================
-//
-String Lexer::describeCurrentPosition()
-{
-	return token()->file + ":" + token()->line;
-}
-
-// =============================================================================
-//
-String Lexer::describeTokenPosition()
-{
-	return format ("%1 / %2", m_tokenPosition - m_tokens.begin(), m_tokens.size());
-}
-
-// =============================================================================
-//
-void Lexer::mustGetSymbol (const String& a)
-{
-	mustGetNext (TK_Any);
-	if (token()->text != a)
-		error ("expected \"%1\", got \"%2\"", a, token()->text);
-}

--- a/src/Lexer.h	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,127 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef BOTC_LEXER_H
-#define BOTC_LEXER_H
-
-#include "Main.h"
-#include "LexerScanner.h"
-
-class Lexer
-{
-public:
-	struct TokenInfo
-	{
-		ETokenType	type;
-		String		text;
-		String		file;
-		int			line;
-		int			column;
-	};
-
-	using TokenList	= List<TokenInfo>;
-	using Iterator	= TokenList::Iterator;
-
-public:
-	Lexer();
-	~Lexer();
-
-	void	processFile (String fileName);
-	bool	next (ETokenType req = TK_Any);
-	void	mustGetNext (ETokenType tok);
-	void	mustGetAnyOf (const List<ETokenType>& toks);
-	void	mustGetSymbol (const String& a);
-	int		getOneSymbol (const StringList& syms);
-	void	tokenMustBe (ETokenType tok);
-	bool	peekNext (TokenInfo* tk = null);
-	bool	peekNextType (ETokenType req);
-	String	peekNextString (int a = 1);
-	String	describeCurrentPosition();
-	String	describeTokenPosition();
-
-	static Lexer* getCurrentLexer();
-
-	inline bool hasValidToken() const
-	{
-		return (m_tokenPosition < m_tokens.end() && m_tokenPosition >= m_tokens.begin());
-	}
-
-	inline TokenInfo* token() const
-	{
-		assert (hasValidToken() == true);
-		return &(*m_tokenPosition);
-	}
-
-	inline bool isAtEnd() const
-	{
-		return m_tokenPosition == m_tokens.end();
-	}
-
-	inline ETokenType tokenType() const
-	{
-		return token()->type;
-	}
-
-	inline void skip (int a = 1)
-	{
-		m_tokenPosition += a;
-	}
-
-	inline int position()
-	{
-		return m_tokenPosition - m_tokens.begin();
-	}
-
-	inline void setPosition (int pos)
-	{
-		m_tokenPosition = m_tokens.begin() + pos;
-	}
-
-	// If @tok is given, describes the token. If not, describes @tok_type.
-	static inline String describeTokenType (ETokenType toktype)
-	{
-		return describeTokenPrivate (toktype, null);
-	}
-
-	static inline String describeToken (TokenInfo* tok)
-	{
-		return describeTokenPrivate (tok->type, tok);
-	}
-
-private:
-	TokenList		m_tokens;
-	Iterator		m_tokenPosition;
-
-	// read a mandatory token from scanner
-	void mustGetFromScanner (LexerScanner& sc, ETokenType tt =TK_Any);
-	void checkFileHeader (LexerScanner& sc);
-
-	static String describeTokenPrivate (ETokenType tok_type, TokenInfo* tok);
-};
-
-#endif // BOTC_LEXER_H

--- a/src/LexerScanner.cc	Sun Mar 30 21:35:06 2014 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,308 +0,0 @@
-/*
-	Copyright 2012-2014 Santeri Piippo
-	All rights reserved.
-
-	Redistribution and use in source and binary forms, with or without
-	modification, are permitted provided that the following conditions
-	are met:
-
-	1. Redistributions of source code must retain the above copyright
-	   notice, this list of conditions and the following disclaimer.
-	2. Redistributions in binary form must reproduce the above copyright
-	   notice, this list of conditions and the following disclaimer in the
-	   documentation and/or other materials provided with the distribution.
-	3. The name of the author may not be used to endorse or promote products
-	   derived from this software without specific prior written permission.
-
-	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-	OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-	THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <cstdio>
-#include <cstdlib>
-#include <cassert>
-#include <cstring>
-#include <string>
-#include "LexerScanner.h"
-#include "Lexer.h"
-
-static const String gTokenStrings[] =
-{
-	"<<=",
-	">>=",
-	"==",
-	"!=",
-	"+=",
-	"-=",
-	"*=",
-	"/=",
-	"%=",
-	"<<",
-	">>",
-	">=",
-	"<=",
-	"&&",
-	"||",
-	"++",
-	"--",
-	"'",
-	"$",
-	"(",
-	")",
-	"[",
-	"]",
-	"{",
-	"}",
-	"=",
-	"+",
-	"-",
-	"*",
-	"/",
-	"%",
-	",",
-	"<",
-	">",
-	".",
-	":",
-	";",
-	"#",
-	"!",
-	"&",
-	"|",
-	"^",
-	"?",
-	"->",
-	"bool",
-	"break",
-	"case",
-	"continue",
-	"const",
-	"constexpr",
-	"default",
-	"do",
-	"else",
-	"event",
-	"eventdef",
-	"for",
-	"funcdef",
-	"if",
-	"int",
-	"mainloop",
-	"onenter",
-	"onexit",
-	"state",
-	"switch",
-	"str",
-	"using",
-	"var",
-	"void",
-	"while",
-	"true",
-	"false",
-	"enum",
-	"func",
-	"return",
-};
-
-static_assert (countof (gTokenStrings) == (int)gLastNamedToken + 1,
-	"Count of gTokenStrings is not the same as the amount of named token identifiers.");
-
-// =============================================================================
-//
-LexerScanner::LexerScanner (FILE* fp) :
-	m_line (1)
-{
-	long fsize, bytes;
-
-	fseek (fp, 0l, SEEK_END);
-	fsize = ftell (fp);
-	rewind (fp);
-	m_data = new char[fsize];
-	m_position = m_lineBreakPosition = &m_data[0];
-	bytes = fread (m_data, 1, fsize, fp);
-	assert (bytes >= fsize);
-}
-
-// =============================================================================
-//
-LexerScanner::~LexerScanner()
-{
-	delete m_data;
-}
-
-// =============================================================================
-//
-bool LexerScanner::checkString (const char* c, int flags)
-{
-	bool r = strncmp (m_position, c, strlen (c)) == 0;
-
-	// There is to be a non-symbol character after words
-	if (r && (flags & FCheckWord) && isSymbolChar (m_position[strlen (c)], true))
-		r = false;
-
-	// Advance the cursor unless we want to just peek
-	if (r && !(flags & FCheckPeek))
-		m_position += strlen (c);
-
-	return r;
-}
-
-// =============================================================================
-//
-bool LexerScanner::getNextToken()
-{
-	m_tokenText = "";
-
-	while (isspace (*m_position))
-		skip();
-
-	// Check for comments
-	if (strncmp (m_position, "//", 2) == 0)
-	{
-		m_position += 2;
-
-		while (*m_position != '\n')
-			skip();
-
-		return getNextToken();
-	}
-	elif (strncmp (m_position, "/*", 2) == 0)
-	{
-		skip (2); // skip the start symbols
-
-		while (strncmp (m_position, "*/", 2) != 0)
-			skip();
-
-		skip (2); // skip the end symbols
-		return getNextToken();
-	}
-
-	if (*m_position == '\0')
-		return false;
-
-	// Check tokens
-	for (int i = 0; i < countof (gTokenStrings); ++i)
-	{
-		int flags = 0;
-
-		if (i >= gFirstNamedToken)
-			flags |= FCheckWord;
-
-		if (checkString (gTokenStrings[i], flags))
-		{
-			m_tokenText = gTokenStrings[i];
-			m_tokenType = (ETokenType) i;
-			return true;
-		}
-	}
-
-	// Check and parse string
-	if (*m_position == '\"')
-	{
-		m_position++;
-
-		while (*m_position != '\"')
-		{
-			if (!*m_position)
-				error ("unterminated string");
-
-			if (checkString ("\\n"))
-			{
-				m_tokenText += '\n';
-				continue;
-			}
-			elif (checkString ("\\t"))
-			{
-				m_tokenText += '\t';
-				continue;
-			}
-			elif (checkString ("\\\""))
-			{
-				m_tokenText += '"';
-				continue;
-			}
-
-			m_tokenText += *m_position++;
-		}
-
-		m_tokenType =TK_String;
-		skip(); // skip the final quote
-		return true;
-	}
-
-	if (isdigit (*m_position))
-	{
-		while (isdigit (*m_position))
-			m_tokenText += *m_position++;
-
-		m_tokenType =TK_Number;
-		return true;
-	}
-
-	if (isSymbolChar (*m_position, false))
-	{
-		m_tokenType =TK_Symbol;
-
-		do
-		{
-			if (!isSymbolChar (*m_position, true))
-				break;
-
-			m_tokenText += *m_position++;
-		} while (*m_position != '\0');
-
-		return true;
-	}
-
-	error ("unknown character \"%1\"", *m_position);
-	return false;
-}
-
-// =============================================================================
-//
-void LexerScanner::skip()
-{
-	if (*m_position == '\n')
-	{
-		m_line++;
-		m_lineBreakPosition = m_position;
-	}
-
-	m_position++;
-}
-
-// =============================================================================
-//
-void LexerScanner::skip (int chars)
-{
-	for (int i = 0; i < chars; ++i)
-		skip();
-}
-
-// =============================================================================
-//
-String LexerScanner::getTokenString (ETokenType a)
-{
-	assert ((int) a <= gLastNamedToken);
-	return gTokenStrings[a];
-}
-
-// =============================================================================
-//
-String LexerScanner::readLine()
-{
-	String line;
-
-	while (*m_position != '\n')
-		line += *(m_position++);
-
-	return line;
-}