Mercurial > botc / changeset

--- a/src/commands.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/commands.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -36,7 +36,7 @@
 
 static List<CommandInfo*> Commands;
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void addCommandDefinition (CommandInfo* comm)
 {
@@ -53,7 +53,7 @@
 	Commands << comm;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 // Finds a command by name
 CommandInfo* findCommandByName (String fname)
 {
@@ -66,7 +66,7 @@
 	return null;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Returns the prototype of the command
 //

--- a/src/dataBuffer.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/dataBuffer.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -29,14 +29,14 @@
 #include <cstring>
 #include "dataBuffer.h"
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 DataBuffer::DataBuffer (int size) :
 	m_buffer (new char[size]),
 	m_allocatedSize (size),
 	m_position (&buffer()[0]) {}
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 DataBuffer::~DataBuffer()
 {
@@ -45,7 +45,7 @@
 	delete buffer();
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Copies the contents of the given buffer into this buffer. The other buffer's marks and 
 //	references will be moved along and the buffer is then destroyed.
@@ -63,7 +63,7 @@
 	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.
@@ -107,7 +107,7 @@
 	m_references.clear();
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Adds a new mark to the current position with the given name
 //
@@ -120,7 +120,7 @@
 	return mark;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Adds a new reference to the given mark at the current position. This function will write 4 
 //	bytes to the buffer whose value will be determined at final output writing.
@@ -138,7 +138,7 @@
 	return ref;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Moves the given mark to the current bytecode position.
 //
@@ -147,7 +147,7 @@
 	mark->pos = writtenSize();
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Shifts the given mark by the amount of bytes
 //
@@ -156,7 +156,7 @@
 	mark->pos += bytes;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Writes a push of the index of the given string. 8 bytes will be written and the string index
 //	will be pushed to stack.
@@ -167,7 +167,7 @@
 	writeDWord (getStringTableIndex (a));
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Writes a data header. 4 bytes.
 //
@@ -176,7 +176,7 @@
 	writeDWord (static_cast<int32_t> (data));
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Prints the buffer to stdout.
 //
@@ -186,7 +186,7 @@
 		printf ("%d. [0x%X]\n", i, buffer()[i]);
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 // Ensures there's at least the given amount of 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.
@@ -219,7 +219,7 @@
 	delete copy;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Writes the given byte into the buffer.
 //
@@ -229,7 +229,7 @@
 	*m_position++ = data;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Writes the given word into the buffer. 2 bytes will be written.
 //
@@ -241,7 +241,7 @@
 		*m_position++ = (data >> (i * 8)) & 0xFF;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Writes the given dword into the buffer. 4bytes will be written.
 //
@@ -253,7 +253,7 @@
 		*m_position++ = (data >> (i * 8)) & 0xFF;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Writes the given string to the databuffer. The string will be written as-is without using string
 //	indices. This will write 4 + length bytes. No header will be written.
@@ -267,7 +267,7 @@
 		writeByte (c);
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Tries to locate the mark by the given name. Returns null if not found.
 //

--- a/src/dataBuffer.h	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/dataBuffer.h	Tue Jul 22 12:57:46 2014 +0300
@@ -32,7 +32,7 @@
 #include "main.h"
 #include "stringTable.h"
 
-// ------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	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
@@ -84,7 +84,7 @@
 	void			copyBuffer (const DataBuffer* buf);
 };
 
-// ------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 //	Returns the amount of bytes written into the buffer.
 //

--- a/src/events.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/events.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -37,14 +37,14 @@
 
 static List<EventDefinition*> Events;
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void addEvent (EventDefinition* e)
 {
 	Events << e;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Finds an event definition by index
 //
@@ -53,7 +53,7 @@
 	return Events[idx];
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Finds an event definition by name
 //

--- a/src/expression.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/expression.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -35,7 +35,7 @@
 	{Token::QuestionMark,		110,	3,	DataHeader::NumDataHeaders	},
 };
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 Expression::Expression (BotscriptParser* parser, Lexer* lx, DataType reqtype) :
 	m_parser (parser),
@@ -58,7 +58,7 @@
 	evaluate();
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 Expression::~Expression()
 {
@@ -66,7 +66,7 @@
 		delete sym;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 // Try to parse an expression symbol (i.e. an operator or operand or a colon)
 // from the lexer.
@@ -200,7 +200,7 @@
 	return null;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 // The symbol parsing process only does token-based checking for operators.
 // Thus ALL minus operators are actually unary minuses simply because both
@@ -224,7 +224,7 @@
 	}
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 // Verifies a single value. Helper function for Expression::verify.
 //
@@ -247,7 +247,7 @@
 	verified[i] = true;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 // Ensures the expression is valid and well-formed and not OMGWTFBBQ. Throws an
 // error if this is not the case.
@@ -364,7 +364,7 @@
 }
 
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 // Which operator to evaluate?
 //
@@ -391,7 +391,7 @@
 	return best;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 // Process the given operator and values into a new value.
 //
@@ -531,7 +531,7 @@
 	return newval;
 }
 
-// -------------------------------------------------------------------------------------------------
+// _________________________________________________________________________________________________
 //
 ExpressionValue* Expression::evaluate()
 {
@@ -595,41 +595,41 @@
 	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()
 {

--- a/src/format.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/format.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -31,6 +31,7 @@
 #include "format.h"
 #include "lexer.h"
 
+// _________________________________________________________________________________________________
 //
 // Throws an error while formatting the string
 //
@@ -47,6 +48,7 @@
 	throw std::logic_error (errmsg.stdString());
 }
 
+// _________________________________________________________________________________________________
 //
 // Main formatter algorithm function. Processes @fmtstr with @args and returns
 // the result.
@@ -104,6 +106,7 @@
 	return fmt;
 }
 
+// _________________________________________________________________________________________________
 //
 // Throws a runtime error with the message @msg. If a lexer is active, its
 // position is printed as well.

--- a/src/lexer.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/lexer.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -32,7 +32,7 @@
 static StringList	FileNameStack;
 static Lexer*		MainLexer = null;
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 Lexer::Lexer()
 {
@@ -40,14 +40,14 @@
 	MainLexer = this;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 Lexer::~Lexer()
 {
 	MainLexer = null;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 void Lexer::processFile (String fileName)
 {
@@ -143,7 +143,7 @@
 		error ("Not a valid botscript file! File must start with '#!botc <version>'");
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 bool Lexer::next (Token req)
 {
@@ -163,7 +163,7 @@
 	return true;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 void Lexer::mustGetNext (Token tok)
 {
@@ -174,7 +174,7 @@
 		tokenMustBe (tok);
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 // eugh..
 //
 void Lexer::mustGetFromScanner (LexerScanner& sc, Token tt)
@@ -197,7 +197,7 @@
 	}
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 void Lexer::mustGetAnyOf (const List<Token>& toks)
 {
@@ -223,7 +223,7 @@
 	error ("expected %1, got %2", toknames, DescribeToken (token()));
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 int Lexer::getOneSymbol (const StringList& syms)
 {
@@ -243,7 +243,7 @@
 	return -1;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 void Lexer::tokenMustBe (Token tok)
 {
@@ -252,7 +252,7 @@
 			DescribeToken (token()));
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 String Lexer::DescribeTokenPrivate (Token tokType, Lexer::TokenInfo* tok)
 {
@@ -271,7 +271,7 @@
 	return "";
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 bool Lexer::peekNext (Lexer::TokenInfo* tk)
 {
@@ -285,7 +285,7 @@
 	return r;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 bool Lexer::peekNextType (Token req)
 {
@@ -299,14 +299,14 @@
 	return result;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 Lexer* Lexer::GetCurrentLexer()
 {
 	return MainLexer;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 String Lexer::peekNextString (int a)
 {
@@ -320,21 +320,21 @@
 	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)
 {

--- a/src/lexerScanner.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/lexerScanner.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -114,7 +114,7 @@
 static_assert (countof (gTokenStrings) == (int) LastNamedToken + 1,
 	"Count of gTokenStrings is not the same as the amount of named token identifiers.");
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 LexerScanner::LexerScanner (FILE* fp) :
 	m_line (1)
@@ -130,14 +130,14 @@
 	ASSERT_GT_EQ (bytes, fsize)
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 LexerScanner::~LexerScanner()
 {
 	delete m_data;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 bool LexerScanner::checkString (const char* c, int flags)
 {
@@ -154,7 +154,7 @@
 	return r;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 bool LexerScanner::getNextToken()
 {
@@ -265,7 +265,7 @@
 	return false;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 void LexerScanner::skip()
 {
@@ -278,7 +278,7 @@
 	m_position++;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 void LexerScanner::skip (int chars)
 {
@@ -286,7 +286,7 @@
 		skip();
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 String LexerScanner::GetTokenString (Token a)
 {
@@ -294,7 +294,7 @@
 	return gTokenStrings[int (a)];
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 String LexerScanner::readLine()
 {

--- a/src/main.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/main.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -113,7 +113,7 @@
 	}
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Mutates given filename to an object filename
 //
@@ -129,7 +129,7 @@
 	return s;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 DataType getTypeByName (String token)
 {
@@ -142,7 +142,7 @@
 }
 
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Inverse operation - type name by value
 //
@@ -160,7 +160,7 @@
 	return "";
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 String makeVersionString (int major, int minor, int patch)
 {
@@ -173,7 +173,7 @@
 	return ver;
 }
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 String versionString (bool longform)
 {

--- a/src/parser.cpp	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/parser.cpp	Tue Jul 22 12:57:46 2014 +0300
@@ -40,7 +40,7 @@
 
 static const StringList g_validZandronumVersions = {"1.2", "1.3", "2.0"};
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 BotscriptParser::BotscriptParser() :
 	m_isReadOnly (false),
@@ -60,14 +60,14 @@
 	m_zandronumVersion (10200), // 1.2
 	m_defaultZandronumVersion (true) {}
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 BotscriptParser::~BotscriptParser()
 {
 	delete m_lexer;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::checkToplevel()
 {
@@ -75,7 +75,7 @@
 		error ("%1-statements may only be defined at top level!", getTokenString());
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::checkNotToplevel()
 {
@@ -83,7 +83,7 @@
 		error ("%1-statements must not be defined at top level!", getTokenString());
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Main compiler code. Begins read of the script file, checks the syntax of it
 // and writes the data to the object file via Objwriter - which also takes care
@@ -229,7 +229,8 @@
 		{
 			print ("\n");
 			print ("note: use the 'using' directive to define a target Zandronum version\n");
-			print ("usage: using zandronum <version>, possible versions: %1\n", g_validZandronumVersions);
+			print ("usage: using zandronum <version>, possible versions: %1\n", 
+g_validZandronumVersions);
 			print ("\n");
 		}
 
@@ -241,7 +242,7 @@
 	}
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseStateBlock()
 {
@@ -276,7 +277,7 @@
 	m_gotMainLoop = false;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseEventBlock()
 {
@@ -295,7 +296,7 @@
 	m_numEvents++;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseMainloop()
 {
@@ -306,7 +307,7 @@
 	m_mainLoopBuffer->writeHeader (DataHeader::MainLoop);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseOnEnterExit()
 {
@@ -317,7 +318,7 @@
 	currentBuffer()->writeHeader (onenter ? DataHeader::OnEnter : DataHeader::OnExit);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseVar()
 {
@@ -414,7 +415,7 @@
 "state-local");
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseIf()
 {
@@ -445,7 +446,7 @@
 	SCOPE (0).type = SCOPE_If;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseElse()
 {
@@ -469,7 +470,7 @@
 	SCOPE (0).type = SCOPE_Else;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseWhileBlock()
 {
@@ -502,7 +503,7 @@
 	SCOPE (0).type = SCOPE_While;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseForBlock()
 {
@@ -554,7 +555,7 @@
 	SCOPE (0).type = SCOPE_For;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseDoBlock()
 {
@@ -565,7 +566,7 @@
 	SCOPE (0).type = SCOPE_Do;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseSwitchBlock()
 {
@@ -593,7 +594,7 @@
 	SCOPE (0).buffer1 = null; // default header
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseSwitchCase()
 {
@@ -630,7 +631,7 @@
 	SCOPE (0).casecursor->number = num;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseSwitchDefault()
 {
@@ -656,7 +657,7 @@
 	addSwitchCase (buf);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseBreak()
 {
@@ -687,7 +688,7 @@
 	m_lexer->mustGetNext (Token::Semicolon);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseContinue()
 {
@@ -719,7 +720,7 @@
 		error ("`continue`-statement not inside a loop");
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::parseBlockEnd()
 {
@@ -837,7 +838,8 @@
 	m_lexer->next (Token::Semicolon);
 }
 
-// =============================================================================
+// 
+-------------------------------------------------------------------------------------------------=
 //
 void BotscriptParser::parseEventdef()
 {
@@ -854,7 +856,8 @@
 	addEvent (e);
 }
 
-// =============================================================================
+// 
+-------------------------------------------------------------------------------------------------=
 //
 void BotscriptParser::parseFuncdef()
 {
@@ -927,7 +930,7 @@
 	addCommandDefinition (comm);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Parses a using statement
 //
@@ -937,9 +940,11 @@
 	m_lexer->mustGetSymbol ("zandronum");
 	String versionText;
 
-	while (m_lexer->next() and (m_lexer->tokenType() == Token::Number or m_lexer->tokenType() == 
-Token::Dot))
+	while (m_lexer->next()
+		and (m_lexer->tokenType() == Token::Number or m_lexer->tokenType() == Token::Dot))
+	{
 		versionText += getTokenString();
+	}
 
 	// Note: at this point the lexer's pointing at the token after the version.
 	if (versionText.isEmpty())
@@ -955,7 +960,7 @@
 	m_lexer->tokenMustBe (Token::Semicolon);
 }
 
-// ============================================================================/
+// _________________________________________________________________________________________________
 //
 // Parses a command call
 //
@@ -985,8 +990,10 @@
 		}
 
 		if (curarg >= comm->args.size())
+		{
 			error ("too many arguments (%3) passed to %1\n\tusage is: %2",
 				comm->name, comm->signature());
+		}
 
 		r->mergeAndDestroy (parseExpression (comm->args[curarg].type, true));
 		m_lexer->mustGetNext (Token::Any);
@@ -1029,7 +1036,7 @@
 	return r;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 String BotscriptParser::parseFloat()
 {
@@ -1049,7 +1056,7 @@
 	return floatstring;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Parses an assignment operator.
 //
@@ -1086,39 +1093,70 @@
 	return (AssignmentOperator) 0;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
-struct AssignmentDataHeaderInfo
+const struct AssignmentDataHeaderInfo
 {
 	AssignmentOperator	op;
 	DataHeader			local;
 	DataHeader			global;
 	DataHeader			array;
-};
-
-const AssignmentDataHeaderInfo gAssignmentDataHeaders[] =
+}
+AssignmentDataHeaders[] =
 {
-	{ ASSIGNOP_Assign,		DataHeader::AssignLocalVar,		DataHeader::AssignGlobalVar,		
-DataHeader::AssignGlobalArray },
-	{ ASSIGNOP_Add,			DataHeader::AddLocalVar,			DataHeader::AddGlobalVar,		
-DataHeader::AddGlobalArray },
-	{ ASSIGNOP_Subtract,	DataHeader::SubtractLocalVar,	DataHeader::SubtractGlobalVar,	
-DataHeader::SubtractGlobalArray },
-	{ ASSIGNOP_Multiply,	DataHeader::MultiplyLocalVar,	DataHeader::MultiplyGlobalVar,	
-DataHeader::MultiplyGlobalArray },
-	{ ASSIGNOP_Divide,		DataHeader::DivideLocalVar,		DataHeader::DivideGlobalVar,		
-DataHeader::DivideGlobalArray },
-	{ ASSIGNOP_Modulus,		DataHeader::ModLocalVar,			DataHeader::ModGlobalVar,		
-DataHeader::ModGlobalArray },
-	{ ASSIGNOP_Increase,	DataHeader::IncreaseLocalVar,	DataHeader::IncreaseGlobalVar,	
-DataHeader::IncreaseGlobalArray },
-	{ ASSIGNOP_Decrease,	DataHeader::DecreaseLocalVar,	DataHeader::DecreaseGlobalVar,	
-DataHeader::DecreaseGlobalArray },
+	{
+		ASSIGNOP_Assign,
+		DataHeader::AssignLocalVar,
+		DataHeader::AssignGlobalVar,
+		DataHeader::AssignGlobalArray
+	},
+	{
+		ASSIGNOP_Add,
+		DataHeader::AddLocalVar,
+		DataHeader::AddGlobalVar,
+		DataHeader::AddGlobalArray
+	},
+	{
+		ASSIGNOP_Subtract,
+		DataHeader::SubtractLocalVar,
+		DataHeader::SubtractGlobalVar,
+		DataHeader::SubtractGlobalArray
+	},
+	{
+		ASSIGNOP_Multiply,
+		DataHeader::MultiplyLocalVar,
+		DataHeader::MultiplyGlobalVar,
+		DataHeader::MultiplyGlobalArray
+	},
+	{
+		ASSIGNOP_Divide,
+		DataHeader::DivideLocalVar,
+		DataHeader::DivideGlobalVar,
+		DataHeader::DivideGlobalArray
+	},
+	{
+		ASSIGNOP_Modulus,
+		DataHeader::ModLocalVar,
+		DataHeader::ModGlobalVar,
+		DataHeader::ModGlobalArray
+	},
+	{
+		ASSIGNOP_Increase,
+		DataHeader::IncreaseLocalVar,
+		DataHeader::IncreaseGlobalVar,
+		DataHeader::IncreaseGlobalArray
+	},
+	{
+		ASSIGNOP_Decrease,
+		DataHeader::DecreaseLocalVar,
+		DataHeader::DecreaseGlobalVar,
+		DataHeader::DecreaseGlobalArray
+	},
 };
 
 DataHeader BotscriptParser::getAssigmentDataHeader (AssignmentOperator op, Variable* var)
 {
-	for (const auto& a : gAssignmentDataHeaders)
+	for (const auto& a : AssignmentDataHeaders)
 	{
 		if (a.op != op)
 			continue;
@@ -1136,7 +1174,7 @@
 	return (DataHeader) 0;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Parses an assignment. An assignment starts with a variable name, followed
 // by an assignment operator, followed by an expression value. Expects current
@@ -1193,7 +1231,7 @@
 	return retbuf;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::pushScope (bool noreset)
 {
@@ -1228,7 +1266,7 @@
 	SCOPE(0).globalVariables.clear();
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 DataBuffer* BotscriptParser::parseExpression (DataType reqtype, bool fromhere)
 {
@@ -1244,7 +1282,7 @@
 	return expr.getResult()->buffer()->clone();
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 DataBuffer* BotscriptParser::parseStatement()
 {
@@ -1263,7 +1301,7 @@
 	return null;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::addSwitchCase (DataBuffer* casebuffer)
 {
@@ -1288,21 +1326,21 @@
 	info->casecursor++;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 bool BotscriptParser::tokenIs (Token a)
 {
 	return (m_lexer->tokenType() == a);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 String BotscriptParser::getTokenString()
 {
 	return m_lexer->token()->text;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 String BotscriptParser::describePosition() const
 {
@@ -1310,7 +1348,9 @@
 	return tok->file + ":" + String (tok->line) + ":" + String (tok->column);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
+//
+//	Where are we writing to right now?
 //
 DataBuffer* BotscriptParser::currentBuffer()
 {
@@ -1326,7 +1366,7 @@
 	return m_mainBuffer;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::writeMemberBuffers()
 {
@@ -1350,7 +1390,7 @@
 	m_gotMainLoop = false;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Write string table
 //
@@ -1370,7 +1410,7 @@
 		m_mainBuffer->writeString (getStringTable()[i]);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Write the compiled bytecode to a file
 //
@@ -1394,7 +1434,7 @@
 	fclose (fp);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Attempt to find the variable by the given name. Looks from current scope
 // downwards.
@@ -1413,7 +1453,7 @@
 	return null;
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Is the parser currently in global state (i.e. not in any specific state)?
 //
@@ -1422,7 +1462,7 @@
 	return m_currentState.isEmpty();
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 void BotscriptParser::suggestHighestVarIndex (bool global, int index)
 {
@@ -1432,7 +1472,7 @@
 		m_highestStateVarIndex = max (m_highestStateVarIndex, index);
 }
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 int BotscriptParser::getHighestVarIndex (bool global)
 {

--- a/src/parser.h	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/parser.h	Tue Jul 22 12:57:46 2014 +0300
@@ -39,7 +39,8 @@
 class Lexer;
 class Variable;
 
-// ============================================================================
+// _________________________________________________________________________________________________
+//
 // Mark types
 //
 named_enum MarkType : char
@@ -49,7 +50,8 @@
 	MARK_Internal, // internal structures
 };
 
-// ============================================================================
+// _________________________________________________________________________________________________
+//
 // Scope types
 //
 named_enum ScopeType : char
@@ -82,7 +84,7 @@
 	WRITE_Constexpr,	// const variable whose value is known to compiler
 };
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 // Parser mode: where is the parser at?
 //
@@ -95,7 +97,7 @@
 	Onexit,		// inside onexit
 };
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 struct Variable
 {
@@ -114,7 +116,7 @@
 	}
 };
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 struct CaseInfo
 {
@@ -123,7 +125,7 @@
 	DataBuffer*		data;
 };
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 // Meta-data about scopes
 //
@@ -145,7 +147,7 @@
 	List<Variable*>				globalArrays;
 };
 
-// ============================================================================
+// _________________________________________________________________________________________________
 //
 class BotscriptParser
 {

--- a/src/tokens.h	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/tokens.h	Tue Jul 22 12:57:46 2014 +0300
@@ -32,7 +32,6 @@
 #include <climits>
 #include "macros.h"
 
-// =======================================================
 named_enum class Token
 {
 	// Non-word tokens

--- a/src/types.h	Tue Jul 22 04:40:33 2014 +0300
+++ b/src/types.h	Tue Jul 22 12:57:46 2014 +0300
@@ -36,7 +36,7 @@
 
 static const std::nullptr_t null = nullptr;
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 named_enum DataType : char
 {
@@ -47,7 +47,7 @@
 	TYPE_Bool,
 };
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 struct ByteMark
 {
@@ -55,7 +55,7 @@
 	int			pos;
 };
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 struct MarkReference
 {
@@ -63,7 +63,7 @@
 	int			pos;
 };
 
-// =============================================================================
+// _________________________________________________________________________________________________
 //
 // Get absolute value of @a
 //