MHR-21: Lots of improvements and changes to the C++ compiler.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

11 files changed, 382 insertions, 83 deletions

diff --git a/Examples/ExampleCPlusPlus.cxx b/Examples/ExampleCPlusPlus.cxx
index 38bf0c5..b54786d 100644
--- a/Examples/ExampleCPlusPlus.cxx
+++ b/Examples/ExampleCPlusPlus.cxx
@@ -1,11 +1,14 @@
-int main(int argc, char const *argv[])
+int main(int argc, char const* argv[])
 {
-    struct ExampleCPlusPlus
-    {
-        int example_data;
-    }* example;
+	int foo = 20;
+	foo -= 1;
 
-    example->example_data = 0;
+	{
+		bool bar = false;
+		bar = true;
 
-    return 0;
+		bool bar2 = bar;
+	}
+
+	return foo;
 }
diff --git a/Examples/ExampleCPlusPlus.s b/Examples/ExampleCPlusPlus.s
index 328bce7..4b69908 100644
--- a/Examples/ExampleCPlusPlus.s
+++ b/Examples/ExampleCPlusPlus.s
@@ -1,14 +1,16 @@
 ; Path: Examples/ExampleCPlusPlus.cxx
 ; Language: MPCC assembly. (Generated from C++)
-; Date: 2024-5-11
+; Date: 2024-5-12
 
 #bits 64
 
 #org 0x1000000
 
+mov r8, 20

+sub r8, 1

+mov r9, 0

+mov r9, 1

+mov r10, r9

 

-

-lea %LEFT+%OFFSET

-

-mov rax, %A0

+mov rax, r10

 ret
\ No newline at end of file
diff --git a/Headers/AsmKit/CPU/64x0.hpp b/Headers/AsmKit/CPU/64x0.hpp
index 3f173ef..58ab76d 100644
--- a/Headers/AsmKit/CPU/64x0.hpp
+++ b/Headers/AsmKit/CPU/64x0.hpp
@@ -42,27 +42,26 @@ inline std::vector<CpuOpcode64x0> kOpcodes64x0 = {
 				   kAsmJump) // jump to linked return register
 	kAsmOpcodeDecl("jrl", 0b1110011, 0b0001111,
 				   kAsmJump) // jump from return register.
-	kAsmOpcodeDecl("mv", 0b0100011, 0b101, kAsmRegToReg) 
-	kAsmOpcodeDecl("bg", 0b1100111, 0b111, kAsmRegToReg) 
-	kAsmOpcodeDecl("bl", 0b1100111, 0b011, kAsmRegToReg)
-	kAsmOpcodeDecl("beq", 0b1100111, 0b000, kAsmRegToReg) 
-	kAsmOpcodeDecl("bne", 0b1100111, 0b001, kAsmRegToReg) 
-	kAsmOpcodeDecl("bge", 0b1100111, 0b101, kAsmRegToReg)
-	kAsmOpcodeDecl("ble", 0b1100111, 0b100, kAsmRegToReg)
-	kAsmOpcodeDecl("stw", 0b0001111, 0b100, kAsmImmediate)
-	kAsmOpcodeDecl("ldw", 0b0001111, 0b100, kAsmImmediate)
-	kAsmOpcodeDecl("lda", 0b0001111, 0b101, kAsmImmediate)
-	kAsmOpcodeDecl("sta", 0b0001111, 0b001, kAsmImmediate)
+	kAsmOpcodeDecl("mv", 0b0100011, 0b101, kAsmRegToReg)
+		kAsmOpcodeDecl("bg", 0b1100111, 0b111, kAsmRegToReg)
+			kAsmOpcodeDecl("bl", 0b1100111, 0b011, kAsmRegToReg)
+				kAsmOpcodeDecl("beq", 0b1100111, 0b000, kAsmRegToReg)
+					kAsmOpcodeDecl("bne", 0b1100111, 0b001, kAsmRegToReg)
+						kAsmOpcodeDecl("bge", 0b1100111, 0b101, kAsmRegToReg)
+							kAsmOpcodeDecl("ble", 0b1100111, 0b100, kAsmRegToReg)
+								kAsmOpcodeDecl("stw", 0b0001111, 0b100, kAsmImmediate)
+									kAsmOpcodeDecl("ldw", 0b0001111, 0b100, kAsmImmediate)
+										kAsmOpcodeDecl("lda", 0b0001111, 0b101, kAsmImmediate)
+											kAsmOpcodeDecl("sta", 0b0001111, 0b001, kAsmImmediate)
 	// add/sub without carry flag
 	kAsmOpcodeDecl("add", 0b0101011, 0b100, kAsmImmediate)
-	kAsmOpcodeDecl("dec", 0b0101011, 0b101, kAsmImmediate)
+		kAsmOpcodeDecl("sub", 0b0101011, 0b101, kAsmImmediate)
 	// add/sub with carry flag
 	kAsmOpcodeDecl("addc", 0b0101011, 0b110, kAsmImmediate)
-	kAsmOpcodeDecl("decc", 0b0101011, 0b111, kAsmImmediate)
-	kAsmOpcodeDecl("int", 0b1110011, 0b00, kAsmSyscall)
-	kAsmOpcodeDecl("pha", 0b1110011, 0b00, kAsmNoArgs)
-	kAsmOpcodeDecl("pla", 0b1110011, 0b01, kAsmNoArgs)
-};
+		kAsmOpcodeDecl("decc", 0b0101011, 0b111, kAsmImmediate)
+			kAsmOpcodeDecl("int", 0b1110011, 0b00, kAsmSyscall)
+				kAsmOpcodeDecl("pha", 0b1110011, 0b00, kAsmNoArgs)
+					kAsmOpcodeDecl("pla", 0b1110011, 0b01, kAsmNoArgs)};
 
 // \brief 64x0 register prefix
 // example: r32, r0
diff --git a/Headers/AsmKit/CPU/amd64.hpp b/Headers/AsmKit/CPU/amd64.hpp
index 403583c..be5a657 100644
--- a/Headers/AsmKit/CPU/amd64.hpp
+++ b/Headers/AsmKit/CPU/amd64.hpp
@@ -38,20 +38,19 @@ struct CpuOpcodeAMD64
 #define kJumpLimitStandardLimit 0xEB
 
 inline std::vector<CpuOpcodeAMD64> kOpcodesAMD64 = {
-	kAsmOpcodeDecl("int", 0xCD) 
-	kAsmOpcodeDecl("into", 0xCE) 
-	kAsmOpcodeDecl("intd", 0xF1) 
-	kAsmOpcodeDecl("int3", 0xC3) 
-	kAsmOpcodeDecl("iret", 0xCF)
-	kAsmOpcodeDecl("retf", 0xCB) 
-	kAsmOpcodeDecl("retn", 0xC3)
-	kAsmOpcodeDecl("ret", 0xC3) 
-	kAsmOpcodeDecl("sti", 0xfb)
-	kAsmOpcodeDecl("cli", 0xfa) 
-	kAsmOpcodeDecl("hlt", 0xf4)
-	kAsmOpcodeDecl("nop", 0x90) 
-	kAsmOpcodeDecl("mov", 0x48)
-	kAsmOpcodeDecl("call", 0xFF)
-};
+	kAsmOpcodeDecl("int", 0xCD)
+		kAsmOpcodeDecl("into", 0xCE)
+			kAsmOpcodeDecl("intd", 0xF1)
+				kAsmOpcodeDecl("int3", 0xC3)
+					kAsmOpcodeDecl("iret", 0xCF)
+						kAsmOpcodeDecl("retf", 0xCB)
+							kAsmOpcodeDecl("retn", 0xC3)
+								kAsmOpcodeDecl("ret", 0xC3)
+									kAsmOpcodeDecl("sti", 0xfb)
+										kAsmOpcodeDecl("cli", 0xfa)
+											kAsmOpcodeDecl("hlt", 0xf4)
+												kAsmOpcodeDecl("nop", 0x90)
+													kAsmOpcodeDecl("mov", 0x48)
+														kAsmOpcodeDecl("call", 0xFF)};
 
 #define kAsmRegisterLimit 15
diff --git a/Headers/ParserKit.hpp b/Headers/ParserKit.hpp
index f14ed69..9f04d11 100644
--- a/Headers/ParserKit.hpp
+++ b/Headers/ParserKit.hpp
@@ -62,19 +62,24 @@ namespace ParserKit
 		eKeywordKindElse,
 		eKeywordKindElseIf,
 		eKeywordKindVariableAssign,
+		eKeywordKindVariableDec,
+		eKeywordKindVariableInc,
 		eKeywordKindConstant,
 		eKeywordKindTypedef,
 		eKeywordKindEndInstr,
 		eKeywordKindSpecifier,
 		eKeywordKindInvalid,
 		eKeywordKindReturn,
+		eKeywordKindCommentInline,
+		eKeywordKindCommentMultiLineStart,
+		eKeywordKindCommentMultiLineEnd,
 	};
 
 	/// \brief Compiler keyword information struct.
 	struct CompilerKeyword
 	{
 		std::string keyword_name;
-		KeywordKind		keyword_kind = eKeywordKindInvalid;
+		KeywordKind keyword_kind = eKeywordKindInvalid;
 	};
 	struct SyntaxLeafList final
 	{
diff --git a/Sources/64asm.cc b/Sources/64asm.cc
index 8f42ea2..96bdc90 100644
--- a/Sources/64asm.cc
+++ b/Sources/64asm.cc
@@ -763,7 +763,7 @@ bool CompilerKit::Encoder64x0::WriteLine(std::string &line,
                 "invalid combination of opcode and registers.\nline: " + line,
                 file);
             throw std::runtime_error("invalid_comb_op_reg");
-          } else if (found_some == 1 && name == "dec") {
+          } else if (found_some == 1 && name == "sub") {
             detail::print_error(
                 "invalid combination of opcode and registers.\nline: " + line,
                 file);
diff --git a/Sources/64x0-cc.cc b/Sources/64x0-cc.cc
index b7ea908..d7b7491 100644
--- a/Sources/64x0-cc.cc
+++ b/Sources/64x0-cc.cc
@@ -736,7 +736,7 @@ bool CompilerBackendCLang::Compile(const std::string& text, const char* file)
 					textBuffer.erase(_text_i, 1);
 			}
 
-			syntaxLeaf.fUserValue += "dec ";
+			syntaxLeaf.fUserValue += "sub ";
 			syntaxLeaf.fUserValue += textBuffer;
 
 			kState.fSyntaxTree->fLeafList.push_back(syntaxLeaf);
@@ -1399,7 +1399,7 @@ public:
 			return -1;
 
 		std::vector<std::string> keywords = {"ldw", "stw", "lda", "sta",
-											 "add", "dec", "mv"};
+											 "add", "sub", "mv"};
 
 		///
 		/// Replace, optimize, fix assembly output.
@@ -1484,7 +1484,7 @@ public:
 					}
 
 					if (cnt > 1 && keyword != "mv" && keyword != "add" &&
-						keyword != "dec")
+						keyword != "sub")
 					{
 						leaf.fUserValue.replace(leaf.fUserValue.find(keyword),
 												keyword.size(), "mv");
diff --git a/Sources/AsmKit.cc b/Sources/AssemblyFactory.cxx
index 38ca551..5a1475f 100644
--- a/Sources/AsmKit.cc
+++ b/Sources/AssemblyFactory.cxx
@@ -8,7 +8,7 @@
 #include <Headers/StdKit/ErrorID.hpp>
 
 /**
- * @file AsmKit.cc
+ * @file AssemblyFactory.cxx
  * @author Amlal El Mahrouss (amlal@mahrouss.com)
  * @brief Assembler Kit
  * @version 0.1
diff --git a/Sources/cplusplus.cc b/Sources/cplusplus.cc
index b61b1d2..14a7af7 100644
--- a/Sources/cplusplus.cc
+++ b/Sources/cplusplus.cc
@@ -33,9 +33,11 @@
 /* This is part of MPCC C++ compiler. */
 /* (c) SoftwareLabs */
 
-// @author Amlal El Mahrouss (amlel)
-// @file cc.cc
-// @brief Optimized C++ Compiler.
+/// @author Amlal El Mahrouss (amlel)
+/// @file cc.cc
+/// @brief Optimized C++ Compiler.
+/// @todo Throw error for scoped inside scoped variables when they get referenced outside.
+/// @todo Add class/struct/enum support.
 
 /////////////////////
 
@@ -110,8 +112,8 @@ namespace detail
 		if (kState.fLastFile != file)
 		{
 			std::cout << kRed << "[ ccplus ] " << kWhite
-					  << ((file == "ccplus") ? "internal compiler error "
-											 : ("in file, " + file))
+					  << ((file == "cplusplus") ? "internal compiler error "
+												: ("in file, " + file))
 					  << kBlank << std::endl;
 			std::cout << kRed << "[ ccplus ] " << kWhite << reason << kBlank
 					  << std::endl;
@@ -208,10 +210,25 @@ const char* CompilerBackendCPlusPlus::Language()
 	return "ISO C++";
 }
 
+static std::vector<std::string> kRegisterMap;
+
+static size_t kLevelFunction = 0UL;
+
+static std::vector<std::string> cRegisters = {
+	"r8",
+	"r9",
+	"r10",
+	"r11",
+	"r12",
+	"r13",
+	"r14",
+	"r15",
+};
+
 /////////////////////////////////////////////////////////////////////////////////////////
 
-// @name Compile
-// @brief Generate MASM from a C++ source.
+/// @name Compile
+/// @brief Generate MASM from a C++ source.
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -228,12 +245,39 @@ bool CompilerBackendCPlusPlus::Compile(const std::string& text,
 	std::size_t														index = 0UL;
 	std::vector<std::pair<ParserKit::CompilerKeyword, std::size_t>> keywords_list;
 
-	bool found = false;
+	bool		found		 = false;
+	static bool commentBlock = false;
 
 	for (auto& keyword : kKeywords)
 	{
 		if (text.find(keyword.keyword_name) != std::string::npos)
 		{
+			switch (keyword.keyword_kind)
+			{
+			case ParserKit::eKeywordKindCommentMultiLineStart: {
+				commentBlock = true;
+				return true;
+			}
+			case ParserKit::eKeywordKindCommentMultiLineEnd: {
+				commentBlock = false;
+				break;
+			}
+			case ParserKit::eKeywordKindCommentInline: {
+				break;
+			}
+			default:
+				break;
+			}
+
+			if (text[text.find(keyword.keyword_name) - 1] == '+' &&
+				keyword.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableAssign)
+				continue;
+
+			if (
+				text[text.find(keyword.keyword_name) - 1] == '-' &&
+				keyword.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableAssign)
+				continue;
+
 			keywords_list.emplace_back(std::make_pair(keyword, index));
 			++index;
 
@@ -241,7 +285,7 @@ bool CompilerBackendCPlusPlus::Compile(const std::string& text,
 		}
 	}
 
-	if (!found)
+	if (!found && !commentBlock)
 	{
 		for (size_t i = 0; i < text.size(); i++)
 		{
@@ -253,39 +297,280 @@ bool CompilerBackendCPlusPlus::Compile(const std::string& text,
 		}
 	}
 
-	static bool shouldEmitWarning = false;
-
 	for (auto& keyword : keywords_list)
 	{
-		if (shouldEmitWarning)
-		{
-			if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindBodyEnd)
-				shouldEmitWarning = false;
-
-			if (shouldEmitWarning)
-			{
-				detail::print_error("code after return: " + text, file);
-			}
-		}
-
 		auto syntax_tree = ParserKit::SyntaxLeafList::SyntaxLeaf();
 
 		switch (keyword.first.keyword_kind)
 		{
-		case ParserKit::KeywordKind::eKeywordKindAccess:
-		case ParserKit::KeywordKind::eKeywordKindPtrAccess:
-			kState.fSyntaxTree->fLeafList[kState.fSyntaxTree->fLeafList.size() - 1].fUserValue = "lea %LEFT+%OFFSET"; // MPCC assembly stipulates this.
-			break;
 		case ParserKit::KeywordKind::eKeywordKindEndInstr:
 			syntax_tree.fUserValue = "\r\n";
 			break;
-		case ParserKit::KeywordKind::eKeywordKindVariableAssign:
-			syntax_tree.fUserValue = "mov %LEFT, %RIGHT";
+		case ParserKit::KeywordKind::eKeywordKindFunctionStart: {
+			++kLevelFunction;
 			break;
-		case ParserKit::KeywordKind::eKeywordKindReturn:
-			syntax_tree.fUserValue = "mov rax, %A0\r\nret";
-			shouldEmitWarning	   = true;
+		}
+		case ParserKit::KeywordKind::eKeywordKindFunctionEnd: {
+			--kLevelFunction;
+
+			if (kRegisterMap.size() > cRegisters.size())
+			{
+				--kLevelFunction;
+			}
+
+			if (kLevelFunction < 1)
+				kRegisterMap.clear();
 			break;
+		}
+		case ParserKit::KeywordKind::eKeywordKindVariableInc:
+		case ParserKit::KeywordKind::eKeywordKindVariableDec:
+		case ParserKit::KeywordKind::eKeywordKindVariableAssign: {
+			auto valueOfVar = text.substr(text.find("=") + 1);
+
+			if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableInc)
+			{
+				valueOfVar = text.substr(text.find("+=") + 2);
+			}
+			else if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableDec)
+			{
+				valueOfVar = text.substr(text.find("-=") + 2);
+			}
+
+			while (valueOfVar.find(";") != std::string::npos)
+			{
+				valueOfVar.erase(valueOfVar.find(";"));
+			}
+
+			if (text.find("float ") != std::string::npos ||
+				text.find("double ") != std::string::npos)
+			{
+				detail::print_error("Vector extensions not supported yet.", "cplusplus");
+			}
+
+			std::string varName = text;
+
+			if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableInc)
+			{
+				varName.erase(varName.find("+="));
+			}
+			else if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableDec)
+			{
+				varName.erase(varName.find("-="));
+			}
+			else
+			{
+				varName.erase(varName.find("="));
+			}
+
+			bool typeFound = false;
+
+			for (auto& keyword : kKeywords)
+			{
+				if (keyword.keyword_kind == ParserKit::eKeywordKindType)
+				{
+					if (varName.find(keyword.keyword_name) != std::string::npos)
+					{
+						typeFound = true;
+						varName.erase(varName.find(keyword.keyword_name), keyword.keyword_name.size());
+					}
+
+					/// in case we goot boolX or intX
+					if (text.find(keyword.keyword_name) != std::string::npos)
+					{
+						if (varName[text.find(keyword.keyword_name)] == ' ')
+							continue;
+
+						typeFound = false;
+					}
+				}
+			}
+
+			std::string instr = "mov ";
+
+			if (typeFound)
+			{
+				if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableInc)
+				{
+					detail::print_error("Can't increment variable when it's being created.", file);
+				}
+				else if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableDec)
+				{
+					detail::print_error("Can't decrement variable when it's being created.", file);
+				}
+
+				if (kRegisterMap.size() > cRegisters.size())
+				{
+					++kLevelFunction;
+				}
+
+				while (varName.find(" ") != std::string::npos)
+				{
+					varName.erase(varName.find(" "), 1);
+				}
+
+				while (varName.find("\t") != std::string::npos)
+				{
+					varName.erase(varName.find("\t"), 1);
+				}
+
+				for (size_t i = 0; !isalnum(valueOfVar[i]); i++)
+				{
+					if (i > valueOfVar.size())
+						break;
+
+					valueOfVar.erase(i, 1);
+				}
+
+				if (valueOfVar == "true")
+				{
+					valueOfVar = "1";
+				}
+				else if (valueOfVar == "false")
+				{
+					valueOfVar = "0";
+				}
+
+				std::size_t indexRight = 0UL;
+
+				for (auto pairRight : kRegisterMap)
+				{
+					++indexRight;
+
+					if (pairRight != valueOfVar)
+					{
+						syntax_tree.fUserValue = instr + cRegisters[kRegisterMap.size()] + ", " + valueOfVar;
+						continue;
+					}
+
+					syntax_tree.fUserValue = instr + cRegisters[kRegisterMap.size()] + ", " + cRegisters[indexRight - 1];
+					break;
+				}
+
+				if (((int)indexRight - 1) < 0)
+				{
+					syntax_tree.fUserValue = instr + cRegisters[kRegisterMap.size()] + ", " + valueOfVar;
+				}
+
+				kRegisterMap.push_back(varName);
+			}
+			else
+			{
+				if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableInc)
+				{
+					instr = "add ";
+				}
+				else if (keyword.first.keyword_kind == ParserKit::KeywordKind::eKeywordKindVariableDec)
+				{
+					instr = "sub ";
+				}
+
+				std::string varErrCpy = varName;
+
+				while (varName.find(" ") != std::string::npos)
+				{
+					varName.erase(varName.find(" "), 1);
+				}
+
+				while (varName.find("\t") != std::string::npos)
+				{
+					varName.erase(varName.find("\t"), 1);
+				}
+
+				std::size_t indxReg = 0UL;
+
+				for (size_t i = 0; !isalnum(valueOfVar[i]); i++)
+				{
+					if (i > valueOfVar.size())
+						break;
+
+					valueOfVar.erase(i, 1);
+				}
+
+				/// interpet boolean values.
+
+				if (valueOfVar == "true")
+				{
+					valueOfVar = "1";
+				}
+				else if (valueOfVar == "false")
+				{
+					valueOfVar = "0";
+				}
+
+				for (auto pair : kRegisterMap)
+				{
+					++indxReg;
+
+					if (pair != varName)
+						continue;
+
+					std::size_t indexRight = 0ul;
+
+					for (auto pairRight : kRegisterMap)
+					{
+						++indexRight;
+
+						if (pairRight != valueOfVar)
+						{
+							syntax_tree.fUserValue = instr + cRegisters[kRegisterMap.size() - 1] + ", " + valueOfVar;
+							continue;
+						}
+
+						syntax_tree.fUserValue = instr + cRegisters[indxReg - 1] + ", " + cRegisters[indexRight - 1];
+						break;
+					}
+
+					break;
+				}
+
+				if (syntax_tree.fUserValue.empty())
+				{
+					detail::print_error("Variable not declared: " + varErrCpy, file);
+				}
+			}
+
+			break;
+		}
+		case ParserKit::KeywordKind::eKeywordKindReturn: {
+			auto		pos		= text.find("return") + strlen("return") + 1;
+			std::string subText = text.substr(pos);
+			subText				= subText.erase(subText.find(";"));
+			size_t indxReg		= 0UL;
+
+			if (subText[0] != '\"' &&
+				subText[0] != '\'')
+			{
+				if (!isdigit(subText[0]))
+				{
+					for (auto pair : kRegisterMap)
+					{
+						++indxReg;
+
+						if (pair != subText)
+							continue;
+
+						syntax_tree.fUserValue = "mov rax, " + cRegisters[indxReg - 1] + "\r\nret";
+						break;
+					}
+
+					if (syntax_tree.fUserValue.empty())
+					{
+						detail::print_error("Variable not declared: " + subText, file);
+					}
+				}
+				else
+				{
+					syntax_tree.fUserValue = "mov rax, " + subText + "\r\nret";
+				}
+			}
+			else
+			{
+				syntax_tree.fUserValue = "mov rcx, " + subText + "\r\n";
+				syntax_tree.fUserValue = "mov rax, rcx\r\nret";
+			}
+
+			break;
+		}
 		default:
 			break;
 		}
@@ -411,6 +696,7 @@ MPCC_MODULE(CompilerCPlusPlus)
 	kKeywords.push_back({.keyword_name = "}", .keyword_kind = ParserKit::eKeywordKindBodyEnd});
 	kKeywords.push_back({.keyword_name = "auto", .keyword_kind = ParserKit::eKeywordKindVariable});
 	kKeywords.push_back({.keyword_name = "int", .keyword_kind = ParserKit::eKeywordKindType});
+	kKeywords.push_back({.keyword_name = "bool", .keyword_kind = ParserKit::eKeywordKindType});
 	kKeywords.push_back({.keyword_name = "unsigned", .keyword_kind = ParserKit::eKeywordKindType});
 	kKeywords.push_back({.keyword_name = "short", .keyword_kind = ParserKit::eKeywordKindType});
 	kKeywords.push_back({.keyword_name = "(", .keyword_kind = ParserKit::eKeywordKindFunctionStart});
@@ -420,6 +706,8 @@ MPCC_MODULE(CompilerCPlusPlus)
 	kKeywords.push_back({.keyword_name = "float", .keyword_kind = ParserKit::eKeywordKindType});
 	kKeywords.push_back({.keyword_name = "double", .keyword_kind = ParserKit::eKeywordKindType});
 	kKeywords.push_back({.keyword_name = "=", .keyword_kind = ParserKit::eKeywordKindVariableAssign});
+	kKeywords.push_back({.keyword_name = "+=", .keyword_kind = ParserKit::eKeywordKindVariableInc});
+	kKeywords.push_back({.keyword_name = "-=", .keyword_kind = ParserKit::eKeywordKindVariableDec});
 	kKeywords.push_back({.keyword_name = "const", .keyword_kind = ParserKit::eKeywordKindConstant});
 	kKeywords.push_back({.keyword_name = "->", .keyword_kind = ParserKit::eKeywordKindPtrAccess});
 	kKeywords.push_back({.keyword_name = ".", .keyword_kind = ParserKit::eKeywordKindAccess});
@@ -431,6 +719,9 @@ MPCC_MODULE(CompilerCPlusPlus)
 	kKeywords.push_back({.keyword_name = "protected:", .keyword_kind = ParserKit::eKeywordKindSpecifier});
 	kKeywords.push_back({.keyword_name = "final", .keyword_kind = ParserKit::eKeywordKindSpecifier});
 	kKeywords.push_back({.keyword_name = "return", .keyword_kind = ParserKit::eKeywordKindReturn});
+	kKeywords.push_back({.keyword_name = "/*", .keyword_kind = ParserKit::eKeywordKindCommentMultiLineStart});
+	kKeywords.push_back({.keyword_name = "*/", .keyword_kind = ParserKit::eKeywordKindCommentMultiLineStart});
+	kKeywords.push_back({.keyword_name = "//", .keyword_kind = ParserKit::eKeywordKindCommentInline});
 
 	kFactory.Mount(new AssemblyMountpointClang());
 	kCompilerBackend = new CompilerBackendCPlusPlus();
diff --git a/posix.make b/posix.make
index 7c937b8..42e0ece 100644
--- a/posix.make
+++ b/posix.make
@@ -19,7 +19,7 @@ LINK_ALT_4_OUTPUT=Output/ppclink.exec
 PP_SRC=Sources/bpp.cc
 PP_OUTPUT=Output/bpp.exec
 
-SRC_COMMON=Sources/String.cc Sources/AsmKit.cc
+SRC_COMMON=Sources/String.cc Sources/AssemblyFactory.cxx
 
 # C++ Compiler (AMD64)
 AMD64_CXX_SRC=Sources/cplusplus.cc $(SRC_COMMON)
diff --git a/win64.make b/win64.make
index 79f46a4..4abac3e 100644
--- a/win64.make
+++ b/win64.make
@@ -19,7 +19,7 @@ LINK_ALT_2_OUTPUT=Output/32link.exe
 PP_SRC=Sources/bpp.cc
 PP_OUTPUT=Output/bpp.exe
 
-SRC_COMMON=Sources/String.cc Sources/AsmKit.cc
+SRC_COMMON=Sources/String.cc Sources/AssemblyFactory.cxx
 
 # C++ Compiler (AMD64)
 AMD64_CXX_SRC=Sources/cplusplus.cc $(SRC_COMMON)