tests

README.md

@@ -10,59 +10,66 @@ There are 3 format types :
  - "int" : 32 bits integers are written. Exemple : `10878976`
  - "binint" : bits are written. Exemple : `00000000 10100110 00000000 00000000`
  - "bin" : the file is written in pure binary
- - "logisim" (default) : the file is written in binary for use in LogiSim
+ - "logisim" (default) : the file is written in hexa for use in LogiSim
 
 ## Exemple
 
 ```assembly
 operations:
-	add R1 R2 R3
-	sub R1 R2 #69
-	and R0 R6 R3
-	xor R1 R2 R3
-	or R1 R7 R3
-	sl R5 R2 #10
-	sr R1 R2 R3
-	mult R1 R1 R3
+	ADD R1 R2 #1
+	SUB R1 R2 R3
+	AND R1 R2 #33
+	XOR R1 R2 R3
+	OR R1 R2 R3
+	SL R1 R2 R3
+	SR R1 R2 R3
+	MUL R1 R2 R3
 io:
-	str R1 R2 R3
-	ld R1 R2 R3
+	STR R1 R2
+	LD R1 R2
 sauts:
-	jmp controle
-	jequ R1 R2 io
-	jneq R1 R2 sauts
-	jsup R1 R2 operations
-	jinf R1 R2 controle
+	JMP controle
+	JEQU R1 R2 io
+	JNEQ R1 R2 sauts
+	JSUP R1 R2 operations
+	JINF R1 R2 controle
 controle:
-	call io
-	ret
+	CALL io
+	RET
 ```
 
 Produces
 
 ```
-00000000 10100110 00000000 00000000
-00010100 10100000 00000000 01000101
+00000100 10100000 00000000 00000001
+00001000 10100110 00000000 00000000
+00010100 10100000 00000000 00100001
 00100000 10100110 00000000 00000000
-01000000 10100110 00000000 00000000
+00011000 10100110 00000000 00000000
+00101000 10100110 00000000 00000000
 00110000 10100110 00000000 00000000
-01010000 10100110 00000000 00000000
-01100000 10100110 00000000 00000000
-01110000 10100110 00000000 00000000
-01000001 01001100 00000000 00000000
-01010001 01001100 00000000 00000000
-11000000 00000000 00000000 00000101
-11010001 01010000 00000000 00000011
-11100001 01010000 00000000 00000010
-11110001 01010000 00000000 00001101
-11000001 01000000 00000000 00000001
-11010100 00000000 00000000 00000111
-11100000 00000000 00000000 00000000
+00111000 10100110 00000000 00000000
+01000000 10100000 00000000 00000000
+01001000 10100000 00000000 00000000
+11000000 00000000 00000000 00001111
+11001000 10100000 00000000 00001000
+11010000 10100000 00000000 00001010
+11011000 10100000 00000000 00000000
+11100000 10100000 00000000 00001111
+11101000 00000000 00000000 00001000
+11111000 00000000 00000000 00000000
 ```
 
+Other examples are located in the `examples` folder
+
+## Releases
+
+Pre-compiled binaries are available in the [Release](https://git.ale-pri.com/Persson-dev/Assembleur/releases) section.
+
 ## Build
 
-You should have [xmake](https://xmake.io) installed
+If you wish to compile yourself, you must have [xmake](https://xmake.io) installed.
+Instructions on how to install (and you should) [here](https://xmake.io/#/guide/installation)
 
 ```bash
 xmake
@@ -71,5 +78,24 @@ xmake
 ## Run
 
 ```bash
-xmake run
+xmake run Assembleur [args]
+```
+
+Example :
+
+```bash
+xmake run Assembleur test.asm -o memory
+```
+
+Parses the file `test.asm` and writes the output into the file `memory`
+
+## Install
+
+You can also add the binary to your path using
+```bash
+xmake install
+```
+or copy the binary in the `bin` folder after
+```
+xmake install -o .
 ```

examples/facto.asm

@@ -0,0 +1,30 @@
+	XOR R0 R0 R0
+	ADD R0 R0 #5	# n = 5
+	XOR R6 R6 R6
+	XOR R7 R7 R7
+	ADD R7 R7 #35	# SP = 40
+	STR R0 R7		# on empile n
+	CALL facto		# on appelle facto dessus
+	JMP fin			# on saute à la fin du programme
+facto:
+	LD R1 R7		# on dépile n
+	JEQU R1 R6 ff	# si n = 0, on retourne 1
+	SUB R2 R1 #1	# sinon, R2 prend n -1
+	ADD R7 R7 #1	# on incrémente le SP
+	STR R2 R7		# on empile n - 1
+	CALL facto		# on appelle facto
+	LD R3 R7		# on dépile le résultat
+	SUB R7 R7 #1	# on décrémente le SP
+	LD R4 R7		# on dépile n
+	MUL R1 R3 R4	# on multiplie n avec facto(n-1)
+	STR R1 R7		# on empile facto(n)
+	RET				# on retourne
+ff:
+	XOR R3 R3 R3	
+	ADD R3 R3 #1	# R3 = 1
+	STR R3 R7		# on empile facto(0) = 1
+	RET				# on retourne
+fin:
+	LD R1 R7		# on met le resultat final dans R1
+stop:
+	JMP stop		# boucle infinie de fin

examples/fibo.asm

@@ -0,0 +1,37 @@
+	XOR R0 R0 R0
+	ADD R0 R0 #7		# n = 7
+	XOR R1 R1 R1
+	ADD R1 R1 #1		# constante à 1
+	XOR R7 R7 R7
+	ADD R7 R7 #40		# SP = 40
+	STR R0 R7			# on empile n
+	CALL fibo			# on appelle fibo dessus
+	JMP fin				# on saute à la fin du programme
+fibo:
+	LD R2 R7			# on dépile n
+	JSUP R2 R1 suite	# si n <= 1, on retourne n (donc on ne fait rien)
+	RET
+suite:
+	SUB R2 R2 #1
+	STR R2 R7			# on empile n - 1
+	ADD R7 R7 #1
+	SUB R2 R2 #1
+	STR R2 R7			# on empile n - 2
+	CALL fibo
+	LD R2 R7			# on dépile fibo(n-2)
+	SUB R7 R7 #1
+	LD R3 R7			# on dépile n - 1
+	STR R2 R7			# on empile fibo(n-2)
+	ADD R7 R7 #1
+	STR R3 R7			# on empile n - 1
+	CALL fibo
+	LD R2 R7			# on dépile fibo(n-1)
+	SUB R7 R7 #1
+	LD R3 R7			# on dépile fibo(n-2)
+	ADD R2 R2 R3
+	STR R2 R7			# on empile fibo(n)
+	RET
+fin:
+	LD R1 R7
+stop:
+	JMP stop

src/Assembleur.cpp

@@ -1,5 +1,6 @@
 #include "Assembleur.h"
 
+#include <algorithm>
 #include <map>
 #include <sstream>
 #include <stdexcept>
@@ -12,7 +13,7 @@ enum TypeArithmetique {
 	Xor,
 	Sl,
 	Sr,
-	Mult,
+	Mul,
 };
 
 enum TypeMemoire {
@@ -27,7 +28,7 @@ enum TypeSautControle {
 	Jsup,
 	Jinf,
 	Call,
-	Ret,
+	Ret = 7,
 };
 
 static std::map<std::string, Instruction> INSTRUCTION_KEYS = {
@@ -38,7 +39,7 @@ static std::map<std::string, Instruction> INSTRUCTION_KEYS = {
 	{"xor", {Arithmetique, Xor}},
 	{"sl", {Arithmetique, Sl}},
 	{"sr", {Arithmetique, Sr}},
-	{"mult", {Arithmetique, Mult}},
+	{"mul", {Arithmetique, Mul}},
 	{"str", {Memoire, Str}},
 	{"ld", {Memoire, Ld}},
 	{"jmp", {SautControle, Jump}},
@@ -50,6 +51,17 @@ static std::map<std::string, Instruction> INSTRUCTION_KEYS = {
 	{"ret", {SautControle, Ret}},
 };
 
+constexpr int LINE_LENGTH = 32;
+constexpr int INSTRUCTION_BITS_COUNT = 2;
+constexpr int OPERATION_BITS_COUNT = 3;
+constexpr int IMMEDIATE_BITS_COUNT = 1;
+constexpr int INSTRUCTION_BLOCK_SIZE = INSTRUCTION_BITS_COUNT + OPERATION_BITS_COUNT + IMMEDIATE_BITS_COUNT;
+constexpr int REGISTRY_BITS_COUNT = 3;
+
+static constexpr int GetOffset(int a_Start, int a_BlockSize) {
+	return LINE_LENGTH - a_Start - a_BlockSize;
+}
+
 std::uint32_t Assembleur::ParseLabel(const std::string& a_Label) {
 	auto it = m_Labels.find(a_Label);
 
@@ -57,47 +69,60 @@ std::uint32_t Assembleur::ParseLabel(const std::string& a_Label) {
 		throw std::invalid_argument("Label " + a_Label + " not found !");
 	}
 
-	return it->second;
+	// the address starts at 0, not 1
+	return it->second - 1;
 }
 
 void Assembleur::AddLabel(const std::string& a_Label, std::uint32_t a_Line) {
 	m_Labels.insert({a_Label, a_Line});
 }
 
+// 2 bits type instruction | 3 bits sous-type opération
 std::uint32_t Assembleur::IToInt(Instruction a_Instruction) {
-	return static_cast<std::uint32_t>(a_Instruction.m_Instruction) << 30 | static_cast<std::uint32_t>(a_Instruction.m_SubInstruction)
-																			   << 28;
+	return static_cast<std::uint32_t>(a_Instruction.m_Instruction) << GetOffset(0, INSTRUCTION_BITS_COUNT) |
+		   static_cast<std::uint32_t>(a_Instruction.m_SubInstruction) << GetOffset(INSTRUCTION_BITS_COUNT, OPERATION_BITS_COUNT);
 }
 
+// 5 bits instruction | 1 bit immédiat (non utilisé) | 3 bits R1 | 3 bits R2 | 3 bits R3
 std::uint32_t Assembleur::ParseOperation(Instruction a_Instruction, std::uint32_t a_R1, std::uint32_t a_R2, std::uint32_t a_R3) {
-	return IToInt(a_Instruction) | a_R1 << 23 | a_R2 << 20 | a_R3 << 17;
+	return IToInt(a_Instruction) | 
+		a_R1 << GetOffset(INSTRUCTION_BLOCK_SIZE, REGISTRY_BITS_COUNT) | 
+		a_R2 << GetOffset(INSTRUCTION_BLOCK_SIZE + REGISTRY_BITS_COUNT, REGISTRY_BITS_COUNT) | 
+		a_R3 << GetOffset(INSTRUCTION_BLOCK_SIZE + 2 * REGISTRY_BITS_COUNT, REGISTRY_BITS_COUNT);
 }
 
+// 5 bits instruction | 1 bit immédiat | 3 bits R1 | 3 bits R2 | 20 bits constante
 std::uint32_t Assembleur::ParseOperationImmediate(
 	Instruction a_Instruction, std::uint32_t a_R1, std::uint32_t a_R2, std::uint32_t a_C1) {
-	return IToInt(a_Instruction) | 1 << 26 | a_R1 << 23 | a_R2 << 20 | a_C1;
+	return IToInt(a_Instruction) | 1 << GetOffset(INSTRUCTION_BITS_COUNT + OPERATION_BITS_COUNT, IMMEDIATE_BITS_COUNT) | 
+		a_R1 << GetOffset(INSTRUCTION_BLOCK_SIZE, REGISTRY_BITS_COUNT) | 
+		a_R2 << GetOffset(INSTRUCTION_BLOCK_SIZE + REGISTRY_BITS_COUNT, REGISTRY_BITS_COUNT) | 
+		a_C1;
 }
 
+// 5 bits instruction | 1 bit immédiat (non utilisé) | 26 bits adresse du label
 std::uint32_t Assembleur::ParseJump(Instruction a_Instruction, const std::string& a_Label) {
-	std::int32_t jump = ParseLabel(a_Label) - a_Instruction.m_Line;
-	if (jump < 0)
-		jump = std::abs(jump) & 0x7FFFFFF | 0x4000000;
-	return IToInt(a_Instruction) | jump;
+	return IToInt(a_Instruction) | ParseLabel(a_Label) & 0x3FFFFFF;
 }
 
+// 5 bits instruction | 1 bit immédiat (non utilisé) | 3 bits R1 | 3 bits R2 | 20 bits adresse du label
 std::uint32_t Assembleur::ParseJump(Instruction a_Instruction, std::uint8_t a_R1, std::uint8_t a_R2, const std::string& a_Label) {
-	std::int32_t jump = ParseLabel(a_Label) - a_Instruction.m_Line;
-	if (jump < 0)
-		jump = std::abs(jump) & 0xFFFFF | 0x100000;
-	return IToInt(a_Instruction) | a_R1 << 24 | a_R2 << 21 | jump;
+	return IToInt(a_Instruction) | 
+		a_R1 << GetOffset(INSTRUCTION_BLOCK_SIZE, REGISTRY_BITS_COUNT) | 
+		a_R2 << GetOffset(INSTRUCTION_BLOCK_SIZE + REGISTRY_BITS_COUNT, REGISTRY_BITS_COUNT) |
+		ParseLabel(a_Label) & 0xFFFFF;
 }
 
+// 5 bits instruction | 1 bit immédiat (non utilisé)
 std::uint32_t Assembleur::ParseJump(Instruction a_Instruction) {
 	return IToInt(a_Instruction);
 }
 
-std::uint32_t Assembleur::ParseIO(Instruction a_Instruction, std::uint32_t a_R1, std::uint32_t a_R2, std::uint32_t a_R3) {
-	return IToInt(a_Instruction) | a_R1 << 24 | a_R2 << 21 | a_R3 << 18;
+// 5 bits instruction | 1 bit immédiat (non utilisé) | 3 bits R1 | 3 bits R2
+std::uint32_t Assembleur::ParseIO(Instruction a_Instruction, std::uint32_t a_R1, std::uint32_t a_R2) {
+	return IToInt(a_Instruction) | 
+		a_R1 << GetOffset(INSTRUCTION_BLOCK_SIZE, REGISTRY_BITS_COUNT) | 
+		a_R2 << GetOffset(INSTRUCTION_BLOCK_SIZE + REGISTRY_BITS_COUNT, REGISTRY_BITS_COUNT);
 }
 
 
@@ -128,13 +153,15 @@ std::uint32_t Assembleur::ParseInstruction(const std::string& a_Str, std::uint32
 	std::string ins;
 	ss >> ins;
 
+	// to lower case
+	std::transform(ins.begin(), ins.end(), ins.begin(), [](unsigned char c) { return std::tolower(c); });
+
 	auto it = INSTRUCTION_KEYS.find(ins);
 	if (it == INSTRUCTION_KEYS.end()) {
 		throw std::invalid_argument("[Line " + std::to_string(a_RealLine) + "] " + "Instruction \"" + ins + "\" not found !");
 	}
 
 	Instruction instruction = it->second;
-	instruction.m_Line = a_Line;
 
 	try {
 		switch (instruction.m_Instruction) {
@@ -149,9 +176,9 @@ std::uint32_t Assembleur::ParseInstruction(const std::string& a_Str, std::uint32
 			}
 
 			case Memoire: {
-				std::string R1, R2, R3;
-				ss >> R1 >> R2 >> R3;
-				return ParseIO(instruction, ParseRegistry(R1), ParseRegistry(R2), ParseRegistry(R3));
+				std::string R1, R2;
+				ss >> R1 >> R2;
+				return ParseIO(instruction, ParseRegistry(R1), ParseRegistry(R2));
 			}
 
 			case SautControle: {
@@ -178,8 +205,8 @@ std::uint32_t Assembleur::ParseInstruction(const std::string& a_Str, std::uint32
 			}
 		}
 
-	} catch (std::invalid_argument& e) {
-		throw std::invalid_argument("[Line " + std::to_string(a_RealLine) + "] " + e.what());
+	} catch (std::exception& e) {
+		throw std::invalid_argument(" [Line " + std::to_string(a_RealLine) + "] " + e.what() + "\n" + a_Str);
 	}
 
 	return 0;

src/Assembleur.h

@@ -13,7 +13,6 @@ enum TypeInstruction : std::uint8_t {
 struct Instruction {
 	TypeInstruction m_Instruction;
 	std::uint8_t m_SubInstruction;
-	std::uint32_t m_Line;
 };
 
 class Assembleur {
@@ -40,5 +39,5 @@ class Assembleur {
 
 	std::uint32_t ParseJump(Instruction a_Instruction);
 
-	std::uint32_t ParseIO(Instruction a_Instruction, std::uint32_t a_R1, std::uint32_t a_R2, std::uint32_t a_R3);
+	std::uint32_t ParseIO(Instruction a_Instruction, std::uint32_t a_R1, std::uint32_t a_R2);
 };

src/IO.cpp

@@ -99,12 +99,8 @@ void OutputFileLogisim(BinaryData& a_Data, const std::string& fileName, const st
 	for (std::uint32_t number : a_Data) {
 		if (cursor % 8 == 0) {
 			file << std::setfill('0') << std::setw(4) << std::hex << cursor << std::dec << ": ";
-			file << std::bitset<8>(number >> 24) << " " << std::bitset<8>(number >> 16) << " " << std::bitset<8>(number >> 8) << " "
-				 << std::bitset<8>(number) << " ";
-		} else {
-			file << std::bitset<8>(number >> 24) << " " << std::bitset<8>(number >> 16) << " " << std::bitset<8>(number >> 8) << " "
-				 << std::bitset<8>(number) << "\n";
 		}
-		cursor += 4;
+		file << std::setfill('0') << std::setw(8) << std::hex << number << std::dec << (((cursor + 1) % 8 == 0) ? "\n" : " ");
+		cursor++;
 	}
 }

src/main.cpp

@@ -3,7 +3,7 @@
 
 #include "IO.h"
 
-#define ASSEMBLEUR_VERSION "1.1"
+#define ASSEMBLEUR_VERSION "1.9"
 
 int main(int argc, char** argv) {
 

test.asm

@@ -1,21 +1,21 @@
 operations:
-	add R1 R2 R3
-	sub R1 R2 #69
-	and R1 R2 R3
-	xor R1 R2 R3
-	or R1 R2 R3
-	sl R1 R2 R3
-	sr R1 R2 R3
-	mult R1 R2 R3
+	ADD R1 R2 #1
+	SUB R1 R2 R3
+	AND R1 R2 #33
+	XOR R1 R2 R3
+	OR R1 R2 R3
+	SL R1 R2 R3
+	SR R1 R2 R3
+	MUL R1 R2 R3
 io:
-	str R1 R2 R3
-	ld R1 R2 R3
+	STR R1 R2
+	LD R1 R2
 sauts:
-	jmp controle
-	jequ R1 R2 io
-	jneq R1 R2 sauts
-	jsup R1 R2 operations
-	jinf R1 R2 controle
+	JMP controle
+	JEQU R1 R2 io
+	JNEQ R1 R2 sauts
+	JSUP R1 R2 operations
+	JINF R1 R2 controle
 controle:
-	call io
-	ret
+	CALL io
+	RET

test/testUAL.asm

@@ -0,0 +1,68 @@
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+    XOR R2 R2 R2
+    XOR R3 R3 R3
+    XOR R4 R4 R4
+    XOR R5 R5 R5
+    XOR R6 R6 R6
+    XOR R7 R7 R7
+ADD:
+    ADD R0 R0 #1
+    ADD R1 R1 R0
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+SUB:
+    ADD R0 R0 #1
+    ADD R1 R1 #1
+    ADD R2 R2 #2
+    SUB R0 R0 #1
+    SUB R3 R2 R1
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+    XOR R2 R2 R2
+    XOR R3 R3 R3
+AND:
+    ADD R0 R0 #5
+    ADD R1 R1 #3
+    AND R2 R0 #1
+    AND R3 R1 R0
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+    XOR R2 R2 R2
+    XOR R3 R3 R3
+OR:
+    ADD R0 R0 #5
+    ADD R1 R1 #2
+    OR R2 R0 #1
+    OR R3 R1 R0
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+    XOR R2 R2 R2
+    XOR R3 R3 R3
+SL:
+    ADD R0 R0 #5
+    ADD R1 R1 #2
+    SL R2 R0 #1
+    SL R3 R0 R1
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+    XOR R2 R2 R2
+    XOR R3 R3 R3
+SR:
+    ADD R0 R0 #20
+    ADD R1 R1 #2
+    SR R2 R0 #1
+    SR R3 R0 R1
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+    XOR R2 R2 R2
+    XOR R3 R3 R3
+MUL:
+    ADD R0 R0 #20
+    ADD R1 R1 #2
+    MUL R2 R0 #2
+    MUL R3 R0 R1
+    XOR R0 R0 R0
+    XOR R1 R1 R1
+    XOR R2 R2 R2
+    XOR R3 R3 R3

test/testsAutres.asm

@@ -0,0 +1,79 @@
+debut:
+        XOR R0 R0 R0
+        XOR R1 R1 R1
+        XOR R2 R2 R2
+        XOR R3 R3 R3
+        XOR R4 R4 R4
+        XOR R5 R5 R5
+        XOR R6 R6 R6
+        XOR R7 R7 R7
+jump:
+        JMP jump_equ
+        ADD R7 R7 #1
+jump_equ:
+        ADD R0 R0 #1
+        ADD R1 R1 #1
+        JEQU R0 R1 jump_equ2
+        ADD R7 R7 #2
+jump_equ2:
+        ADD R0 R0 #1
+        ADD R6 R6 #1
+        JEQU R0 R1 jump_neq
+        SUB R6 R6 #1
+jump_neq:
+        JNEQ R0 R1 jump_neq2
+        ADD R7 R7 #4
+jump_neq2:
+        ADD R2 R2 #1
+        ADD R6 R6 #2
+        JNEQ R1 R2 jump_sup
+        SUB R6 R6 #2
+jump_sup:
+        JSUP R1 R0 jump_sup2
+        ADD R7 R7 #8
+jump_sup2:
+        ADD R6 R6 #4
+        JSUP R0 R1 jump_inf
+        SUB R6 R6 #4
+jump_inf:
+        JINF R0 R1 jump_inf2
+        ADD R7 R7 #16
+jump_inf2:
+        ADD R6 R6 #8
+        JSUP R1 R0 store
+        SUB R6 R6 #8
+store:
+        XOR R0 R0 R0
+        XOR R1 R1 R1
+        XOR R2 R2 R2
+        ADD R0 R0 #1
+        ADD R1 R1 #24
+        STR R0 R1
+load:
+        LD R0 R2
+        JEQU R1 R2 fin_load
+        ADD R7 R7 #32
+fin_load:
+        XOR R0 R0 R0
+        XOR R1 R1 R1
+        XOR R2 R2 R2
+        XOR R3 R3 R3
+        XOR R4 R4 R4
+        XOR R5 R5 R5
+foo:
+        ADD R0 R0 #1
+        JEQU R0 R1 fin
+        CALL bar
+        RET
+bar:
+        ADD R1 R1 #2
+        CALL foo
+        RET
+fin:
+	ADD R0 R0 #42
+        XOR R0 R0 R0
+        XOR R1 R1 R1
+        XOR R2 R2 R2
+        XOR R3 R3 R3
+        XOR R4 R4 R4
+        XOR R5 R5 R5

xmake.lua

@@ -10,72 +10,6 @@ target("Assembleur")
     set_rundir(".")
     add_packages("argparse")
 
---
--- If you want to known more usage about xmake, please see https://xmake.io
---
--- ## FAQ
---
--- You can enter the project directory firstly before building project.
---
---   $ cd projectdir
---
--- 1. How to build project?
---
---   $ xmake
---
--- 2. How to configure project?
---
---   $ xmake f -p [macosx|linux|iphoneos ..] -a [x86_64|i386|arm64 ..] -m [debug|release]
---
--- 3. Where is the build output directory?
---
---   The default output directory is `./build` and you can configure the output directory.
---
---   $ xmake f -o outputdir
---   $ xmake
---
--- 4. How to run and debug target after building project?
---
---   $ xmake run [targetname]
---   $ xmake run -d [targetname]
---
--- 5. How to install target to the system directory or other output directory?
---
---   $ xmake install
---   $ xmake install -o installdir
---
--- 6. Add some frequently-used compilation flags in xmake.lua
---
--- @code
---    -- add debug and release modes
---    add_rules("mode.debug", "mode.release")
---
---    -- add macro definition
---    add_defines("NDEBUG", "_GNU_SOURCE=1")
---
---    -- set warning all as error
---    set_warnings("all", "error")
---
---    -- set language: c99, c++11
---    set_languages("c99", "c++11")
---
---    -- set optimization: none, faster, fastest, smallest
---    set_optimize("fastest")
---
---    -- add include search directories
---    add_includedirs("/usr/include", "/usr/local/include")
---
---    -- add link libraries and search directories
---    add_links("tbox")
---    add_linkdirs("/usr/local/lib", "/usr/lib")
---
---    -- add system link libraries
---    add_syslinks("z", "pthread")
---
---    -- add compilation and link flags
---    add_cxflags("-stdnolib", "-fno-strict-aliasing")
---    add_ldflags("-L/usr/local/lib", "-lpthread", {force = true})
---
--- @endcode
---
-
+    if is_os("windows") then
+        add_ldflags("-static", "-static-libstdc++")
+    end