From cf8dfce348e0dcead4da8ecd6b1c89be2b8728ef Mon Sep 17 00:00:00 2001
From: Moammad97 <mgh27.1997@gmail.com>
Date: Sat, 24 Oct 2020 12:19:10 +0330
Subject: [PATCH] Some functions code generation handled

---
 hyperdbg/hprdbgctrl/print.cpp             |  912 ++++++++---------
 hyperdbg/include/ScriptEngineCommon.h     |   62 ++
 hyperdbg/script-engine/src/ScriptEngine.c |    6 +-
 hyperdbg/script-engine/src/ScriptEngine.h |   59 +-
 hyperdbg/script-engine/src/scanner.c      | 1134 ++++++++++-----------
 hyperdbg/script-engine/src/scanner.h      |   55 +-
 6 files changed, 1111 insertions(+), 1117 deletions(-)

diff --git a/hyperdbg/hprdbgctrl/print.cpp b/hyperdbg/hprdbgctrl/print.cpp
index 6bd82d31..59d05fc9 100644
--- a/hyperdbg/hprdbgctrl/print.cpp
+++ b/hyperdbg/hprdbgctrl/print.cpp
@@ -1,6 +1,7 @@
 /**
  * @file print.cpp
  * @author Sina Karvandi (sina@rayanfam.com)
+ * @author M.H. Gholamrezei (gholamrezaei.mh@gmail.com)
  * @brief print command
  * @details
  * @version 0.1
@@ -21,9 +22,9 @@ VOID TestParser(string Expr);
  * @return VOID
  */
 VOID CommandPrintHelp() {
-  ShowMessages("print : evaluate expressions.\n\n");
-  ShowMessages("syntax : \tprint [expression]\n");
-  ShowMessages("\t\te.g : print dq(poi(@rcx))\n");
+	ShowMessages("print : evaluate expressions.\n\n");
+	ShowMessages("syntax : \tprint [expression]\n");
+	ShowMessages("\t\te.g : print dq(poi(@rcx))\n");
 }
 
 /**
@@ -34,65 +35,65 @@ VOID CommandPrintHelp() {
  */
 VOID CommandPrint(vector<string> SplittedCommand, string Expr) {
 
-  BOOL Status;
-  ULONG ReturnedLength;
-  DEBUGGER_PRINT PrintRequest = {0};
+	BOOL Status;
+	ULONG ReturnedLength;
+	DEBUGGER_PRINT PrintRequest = { 0 };
 
-  if (SplittedCommand.size() == 1) {
-    ShowMessages("incorrect use of 'print'\n\n");
-    CommandPrintHelp();
-    return;
-  }
+	if (SplittedCommand.size() == 1) {
+		ShowMessages("incorrect use of 'print'\n\n");
+		CommandPrintHelp();
+		return;
+	}
 
-  //
-  // Trim the command
-  //
-  Trim(Expr);
+	//
+	// Trim the command
+	//
+	Trim(Expr);
 
-  //
-  // Remove print from it
-  //
-  Expr.erase(0, 5);
+	//
+	// Remove print from it
+	//
+	Expr.erase(0, 5);
 
-  //
-  // Trim it again
-  //
-  Trim(Expr);
+	//
+	// Trim it again
+	//
+	Trim(Expr);
 
-  //
-  // TODO: end of string must have a whitspace. fix it.
-  //
-  Expr.append(" ");
-  // Expr = " x = 4 >> 1; ";
+	//
+	// TODO: end of string must have a whitspace. fix it.
+	//
+	Expr.append(" ");
+	// Expr = " x = 4 >> 1; ";
 
-  printf("Expression : %s \n", Expr.c_str());
-  TestParser(Expr);
-  return;
+	printf("Expression : %s \n", Expr.c_str());
+	TestParser(Expr);
+	return;
 
-  if (!g_DeviceHandle) {
-    ShowMessages("Handle not found, probably the driver is not loaded. Did you "
-                 "use 'load' command?\n");
-    return;
-  }
+	if (!g_DeviceHandle) {
+		ShowMessages("Handle not found, probably the driver is not loaded. Did you "
+			"use 'load' command?\n");
+		return;
+	}
 
-  //
-  // Send the request to the kernel
-  //
-  Status = DeviceIoControl(g_DeviceHandle,        // Handle to device
-                           IOCTL_DEBUGGER_PRINT,  // IO Control coder
-                           &PrintRequest,         // Input Buffer to driver.
-                           SIZEOF_DEBUGGER_PRINT, // Input buffer length
-                           &PrintRequest,         // Output Buffer from driver.
-                           SIZEOF_DEBUGGER_PRINT, // Length of output buffer
-                                                  // in bytes.
-                           &ReturnedLength,       // Bytes placed in buffer.
-                           NULL                   // synchronous call
-  );
+	//
+	// Send the request to the kernel
+	//
+	Status = DeviceIoControl(g_DeviceHandle,        // Handle to device
+		IOCTL_DEBUGGER_PRINT,  // IO Control coder
+		&PrintRequest,         // Input Buffer to driver.
+		SIZEOF_DEBUGGER_PRINT, // Input buffer length
+		&PrintRequest,         // Output Buffer from driver.
+		SIZEOF_DEBUGGER_PRINT, // Length of output buffer
+							   // in bytes.
+		&ReturnedLength,       // Bytes placed in buffer.
+		NULL                   // synchronous call
+	);
 
-  if (!Status) {
-    ShowMessages("ioctl failed with code 0x%x\n", GetLastError());
-    return;
-  }
+	if (!Status) {
+		ShowMessages("ioctl failed with code 0x%x\n", GetLastError());
+		return;
+	}
 }
 ////////////////////////////////////////////////////////////////////
 //                  Test (Should be removed)
@@ -105,58 +106,6 @@ typedef unsigned long long QWORD;
 #define LOBYTE(w) ((BYTE)(w))
 #define HIBYTE(w) ((BYTE)(((WORD)(w) >> 8) & 0xFF))
 
-#define FUNC_OR 0
-#define FUNC_XOR 1
-#define FUNC_AND 2
-#define FUNC_ASR 3
-#define FUNC_ASL 4
-#define FUNC_ADD 5
-#define FUNC_SUB 6
-#define FUNC_MUL 7
-#define FUNC_DIV 8
-#define FUNC_MOD 9
-#define FUNC_POI 10
-#define FUNC_DB 11
-#define FUNC_DD 12
-#define FUNC_DW 13
-#define FUNC_DQ 14
-#define FUNC_STR 15
-#define FUNC_WSTR 16
-#define FUNC_SIZEOF 17
-#define FUNC_NOT 18
-#define FUNC_NEG 19
-#define FUNC_HI 20
-#define FUNC_LOW 21
-#define FUNC_MOV 22
-
-#define SYMBOL_ID_TYPE 0
-#define SYMBOL_NUM_TYPE 1
-#define SYMBOL_REGISTER_TYPE 2
-#define SYMBOL_PSEUDO_REG_TYPE 3
-#define SYMBOL_SEMANTIC_RULE_TYPE 4
-#define SYMBOL_TEMP_TYPE 5
-
-#define RAX_MNEMONIC 0
-#define RCX_MNEMONIC 1
-#define RDX_MNEMONIC 2
-#define RBX_MNEMONIC 3
-#define RSP_MNEMONIC 4
-#define RBP_MNEMONIC 5
-#define RSI_MNEMONIC 6
-#define RDI_MNEMONIC 7
-#define R8_MNEMONIC 8
-#define R9_MNEMONIC 9
-#define R10_MNEMONIC 10
-#define R11_MNEMONIC 11
-#define R12_MNEMONIC 12
-#define R13_MNEMONIC 13
-#define R14_MNEMONIC 14
-#define R15_MNEMONIC 15
-
-#define INVALID -1
-
-#define TID_MNEMONIC 0
-#define PID_MNEMONIC 1
 
 #define MAX_TEMP_COUNT 32
 
@@ -165,26 +114,26 @@ typedef unsigned long long QWORD;
 #define MAX_VAR_COUNT 32
 
 typedef struct _GUEST_REGS {
-  ULONG64 rax; // 0x00
-  ULONG64 rcx; // 0x08
-  ULONG64 rdx; // 0x10
-  ULONG64 rbx; // 0x18
-  ULONG64 rsp; // 0x20
-  ULONG64 rbp; // 0x28
-  ULONG64 rsi; // 0x30
-  ULONG64 rdi; // 0x38
-  ULONG64 r8;  // 0x40
-  ULONG64 r9;  // 0x48
-  ULONG64 r10; // 0x50
-  ULONG64 r11; // 0x58
-  ULONG64 r12; // 0x60
-  ULONG64 r13; // 0x68
-  ULONG64 r14; // 0x70
-  ULONG64 r15; // 0x78
-} GUEST_REGS, *PGUEST_REGS;
+	ULONG64 rax; // 0x00
+	ULONG64 rcx; // 0x08
+	ULONG64 rdx; // 0x10
+	ULONG64 rbx; // 0x18
+	ULONG64 rsp; // 0x20
+	ULONG64 rbp; // 0x28
+	ULONG64 rsi; // 0x30
+	ULONG64 rdi; // 0x38
+	ULONG64 r8;  // 0x40
+	ULONG64 r9;  // 0x48
+	ULONG64 r10; // 0x50
+	ULONG64 r11; // 0x58
+	ULONG64 r12; // 0x60
+	ULONG64 r13; // 0x68
+	ULONG64 r14; // 0x70
+	ULONG64 r15; // 0x78
+} GUEST_REGS, * PGUEST_REGS;
 
-UINT64 TempList[MAX_TEMP_COUNT] = {0};
-UINT64 VariableList[MAX_VAR_COUNT] = {0};
+UINT64 TempList[MAX_TEMP_COUNT] = { 0 };
+UINT64 VariableList[MAX_VAR_COUNT] = { 0 };
 
 //
 // Pseudo registers
@@ -205,388 +154,419 @@ UINT64 ScriptEngineKeywordPoi(PUINT64 Address) { return *Address; }
 
 // hi
 WORD ScriptEngineKeywordHi(PUINT64 Address) {
-  QWORD Result = *Address;
-  return HIWORD(Result);
+	QWORD Result = *Address;
+	return HIWORD(Result);
 }
 
 // low
 WORD ScriptEngineKeywordLow(PUINT64 Address) {
-  QWORD Result = *Address;
-  return LOWORD(Result);
+	QWORD Result = *Address;
+	return LOWORD(Result);
 }
 
 // db
 BYTE ScriptEngineKeywordDb(PUINT64 Address) {
-  BYTE Result = *Address;
-  return Result;
+	BYTE Result = *Address;
+	return Result;
 }
 
 // dd
 WORD ScriptEngineKeywordDd(PUINT64 Address) {
-  WORD Result = *Address;
-  return Result;
+	WORD Result = *Address;
+	return Result;
 }
 
 // dw
 DWORD ScriptEngineKeywordDw(PUINT64 Address) {
-  DWORD Result = *Address;
-  return Result;
+	DWORD Result = *Address;
+	return Result;
 }
 
 // dq
 QWORD ScriptEngineKeywordDq(PUINT64 Address) {
-  QWORD Result = *Address;
-  return Result;
+	QWORD Result = *Address;
+	return Result;
 }
 
 UINT64 GetRegValue(PGUEST_REGS GuestRegs, PSYMBOL Symbol) {
-  switch (Symbol->Value) {
-  case RAX_MNEMONIC:
-    return GuestRegs->rax;
-  case RCX_MNEMONIC:
-    return GuestRegs->rcx;
-  case RDX_MNEMONIC:
-    return GuestRegs->rdx;
-  case RBX_MNEMONIC:
-    return GuestRegs->rbx;
-  case RSP_MNEMONIC:
-    return GuestRegs->rsp;
-  case RBP_MNEMONIC:
-    return GuestRegs->rbp;
-  case RSI_MNEMONIC:
-    return GuestRegs->rsi;
-  case RDI_MNEMONIC:
-    return GuestRegs->rdi;
-  case R8_MNEMONIC:
-    return GuestRegs->r8;
-  case R9_MNEMONIC:
-    return GuestRegs->r9;
-  case R10_MNEMONIC:
-    return GuestRegs->r10;
-  case R11_MNEMONIC:
-    return GuestRegs->r11;
-  case R12_MNEMONIC:
-    return GuestRegs->r12;
-  case R13_MNEMONIC:
-    return GuestRegs->r13;
-  case R14_MNEMONIC:
-    return GuestRegs->r14;
-  case R15_MNEMONIC:
-    return GuestRegs->r15;
-  case INVALID:
-    printf("Error in reading regesiter");
-    return INVALID;
-    // TODO: Add all the register
-  }
+	switch (Symbol->Value) {
+	case RAX_MNEMONIC:
+		return GuestRegs->rax;
+	case RCX_MNEMONIC:
+		return GuestRegs->rcx;
+	case RDX_MNEMONIC:
+		return GuestRegs->rdx;
+	case RBX_MNEMONIC:
+		return GuestRegs->rbx;
+	case RSP_MNEMONIC:
+		return GuestRegs->rsp;
+	case RBP_MNEMONIC:
+		return GuestRegs->rbp;
+	case RSI_MNEMONIC:
+		return GuestRegs->rsi;
+	case RDI_MNEMONIC:
+		return GuestRegs->rdi;
+	case R8_MNEMONIC:
+		return GuestRegs->r8;
+	case R9_MNEMONIC:
+		return GuestRegs->r9;
+	case R10_MNEMONIC:
+		return GuestRegs->r10;
+	case R11_MNEMONIC:
+		return GuestRegs->r11;
+	case R12_MNEMONIC:
+		return GuestRegs->r12;
+	case R13_MNEMONIC:
+		return GuestRegs->r13;
+	case R14_MNEMONIC:
+		return GuestRegs->r14;
+	case R15_MNEMONIC:
+		return GuestRegs->r15;
+	case INVALID:
+		printf("Error in reading regesiter");
+		return INVALID;
+		// TODO: Add all the register
+	}
 }
 UINT64 GetPseudoRegValue(PSYMBOL Symbol) {
-  switch (Symbol->Value) {
-  case TID_MNEMONIC:
-    return ScriptEnginePseudoRegGetTid();
-  case PID_MNEMONIC:
-    return ScriptEnginePseudoRegGetPid();
-  case INVALID:
-    printf("Error in reading regesiter");
-    return INVALID;
-    // TODO: Add all the register
-  }
+	switch (Symbol->Value) {
+	case TID_MNEMONIC:
+		return ScriptEnginePseudoRegGetTid();
+	case PID_MNEMONIC:
+		return ScriptEnginePseudoRegGetPid();
+	case INVALID:
+		printf("Error in reading regesiter");
+		return INVALID;
+		// TODO: Add all the register
+	}
 }
 UINT64 GetValue(PGUEST_REGS GuestRegs, PSYMBOL Symbol) {
 
-  switch (Symbol->Type) {
-  case SYMBOL_ID_TYPE:
-    return VariableList[Symbol->Value];
-  case SYMBOL_NUM_TYPE:
-    return Symbol->Value;
-  case SYMBOL_REGISTER_TYPE:
-    return GetRegValue(GuestRegs, Symbol);
-  case SYMBOL_PSEUDO_REG_TYPE:
-    return GetPseudoRegValue(Symbol);
-  case SYMBOL_TEMP_TYPE:
-    return TempList[Symbol->Value];
-  }
+	switch (Symbol->Type) {
+	case SYMBOL_ID_TYPE:
+		return VariableList[Symbol->Value];
+	case SYMBOL_NUM_TYPE:
+		return Symbol->Value;
+	case SYMBOL_REGISTER_TYPE:
+		return GetRegValue(GuestRegs, Symbol);
+	case SYMBOL_PSEUDO_REG_TYPE:
+		return GetPseudoRegValue(Symbol);
+	case SYMBOL_TEMP_TYPE:
+		return TempList[Symbol->Value];
+	}
 }
 VOID SetValue(PGUEST_REGS GuestRegs, PSYMBOL Symbol, UINT64 Value) {
-  switch (Symbol->Type) {
-  case SYMBOL_ID_TYPE:
-    VariableList[Symbol->Value] = Value;
-    return;
-  case SYMBOL_TEMP_TYPE:
-    TempList[Symbol->Value] = Value;
-    return;
-  }
+	switch (Symbol->Type) {
+	case SYMBOL_ID_TYPE:
+		VariableList[Symbol->Value] = Value;
+		return;
+	case SYMBOL_TEMP_TYPE:
+		TempList[Symbol->Value] = Value;
+		return;
+	}
 }
 
 //
 VOID ScriptEngineExecute(PGUEST_REGS GuestRegs, PSYMBOL_BUFFER CodeBuffer,
-                         int &Indx) {
-  PSYMBOL Operator;
-  PSYMBOL Src0;
-  PSYMBOL Src1;
-  PSYMBOL Des;
-  UINT64 SrcVal0;
-  UINT64 SrcVal1;
-  UINT64 DesVal;
+	int& Indx) {
+	PSYMBOL Operator;
+	PSYMBOL Src0;
+	PSYMBOL Src1;
+	PSYMBOL Des;
+	UINT64 SrcVal0;
+	UINT64 SrcVal1;
+	UINT64 DesVal;
 
-  Operator = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                       (unsigned long long)(Indx * sizeof(SYMBOL)));
-  Indx++;
-  if (Operator->Type != SYMBOL_SEMANTIC_RULE_TYPE) {
-    printf("Error:Expecting Operator Type.\n");
-  }
+	Operator = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+		(unsigned long long)(Indx * sizeof(SYMBOL)));
+	Indx++;
+	if (Operator->Type != SYMBOL_SEMANTIC_RULE_TYPE) {
+		printf("Error:Expecting Operator Type.\n");
+	}
 
-  Src0 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                   (unsigned long long)(Indx * sizeof(SYMBOL)));
-  Indx++;
-  SrcVal0 = GetValue(GuestRegs, Src0);
-  switch (Operator->Value) {
-  case FUNC_OR:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    SrcVal1 = GetValue(GuestRegs, Src1);
-
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    DesVal = SrcVal1 | SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
-
-    return;
-
-  case FUNC_XOR:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    SrcVal1 = GetValue(GuestRegs, Src1);
-
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    DesVal = SrcVal1 ^ SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
-
-    return;
-
-  case FUNC_AND:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    SrcVal1 = GetValue(GuestRegs, Src1);
-
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    DesVal = SrcVal1 & SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
-
-    return;
-
-  case FUNC_ASR:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    SrcVal1 = GetValue(GuestRegs, Src1);
-
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    DesVal = SrcVal1 >> SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
-
-    return;
-
-  case FUNC_ASL:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    SrcVal1 = GetValue(GuestRegs, Src1);
-
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-
-    DesVal = SrcVal1 << SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
-
-    return;
+	Src0 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+		(unsigned long long)(Indx * sizeof(SYMBOL)));
+	Indx++;
+	SrcVal0 = GetValue(GuestRegs, Src0);
+	switch (Operator->Value) {
+	case FUNC_OR:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-  case FUNC_ADD:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-    SrcVal1 = GetValue(GuestRegs, Src1);
+		SrcVal1 = GetValue(GuestRegs, Src1);
 
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    DesVal = SrcVal1 + SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+		DesVal = SrcVal1 | SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-    return;
-  case FUNC_SUB:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-    SrcVal1 = GetValue(GuestRegs, Src1);
+		return;
 
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+	case FUNC_XOR:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    DesVal = SrcVal1 - SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+		SrcVal1 = GetValue(GuestRegs, Src1);
+
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = SrcVal1 ^ SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-    return;
-  case FUNC_MUL:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-    SrcVal1 = GetValue(GuestRegs, Src1);
+		return;
 
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+	case FUNC_AND:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		SrcVal1 = GetValue(GuestRegs, Src1);
+
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = SrcVal1 & SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
+
+	case FUNC_ASR:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		SrcVal1 = GetValue(GuestRegs, Src1);
+
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = SrcVal1 >> SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
+
+	case FUNC_ASL:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		SrcVal1 = GetValue(GuestRegs, Src1);
+
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = SrcVal1 << SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-    DesVal = SrcVal1 * SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+		return;
 
-    return;
+	case FUNC_ADD:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+		SrcVal1 = GetValue(GuestRegs, Src1);
 
-  case FUNC_DIV:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-    SrcVal1 = GetValue(GuestRegs, Src1);
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+		DesVal = SrcVal1 + SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-    DesVal = SrcVal1 / SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+		return;
 
-    return;
-  case FUNC_MOD:
-    Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                     (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
-    SrcVal1 = GetValue(GuestRegs, Src1);
+	case FUNC_SUB:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+		SrcVal1 = GetValue(GuestRegs, Src1);
 
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    DesVal = SrcVal1 % SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+		DesVal = SrcVal1 - SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-    return;
+		return;
+	case FUNC_MUL:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+		SrcVal1 = GetValue(GuestRegs, Src1);
 
-  case FUNC_POI:
-    // TODO: Hanlde poi function
-    printf("Error: Poi functions is not handled yet.\n");
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    return;
+		DesVal = SrcVal1 * SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-  case FUNC_DB:
-    // TODO: Hanlde db function
-    printf("Error: DB functions is not handled yet.\n");
+		return;
 
-    return;
-  case FUNC_DW:
-    // TODO: Hanlde dw function
-    printf("Error: DW functions is not handled yet.\n");
+	case FUNC_DIV:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+		SrcVal1 = GetValue(GuestRegs, Src1);
 
-    return;
-  case FUNC_DQ:
-    // TODO: Hanlde dq function
-    printf("Error: Dq functions is not handled yet.\n");
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    return;
+		DesVal = SrcVal1 / SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-  case FUNC_STR:
-    // TODO: Hanlde str function
-    printf("Error: STR functions is not handled yet.\n");
+		return;
+	case FUNC_MOD:
+		Src1 = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+		SrcVal1 = GetValue(GuestRegs, Src1);
 
-    return;
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-  case FUNC_WSTR:
-    // TODO: Hanlde wstr function
-    printf("Error: WSTR functions is not handled yet.\n");
+		DesVal = SrcVal1 % SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-    return;
+		return;
 
-  case FUNC_SIZEOF:
-    // TODO: Hanlde sizeof function
-    printf("Error: DB functions is not handled yet.\n");
+	case FUNC_POI:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    return;
+		DesVal = ScriptEngineKeywordPoi((PUINT64)GetValue(GuestRegs, Src0));
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-  case FUNC_NOT:
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+		return;
 
-    DesVal = ~SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+	case FUNC_DB:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    return;
+		DesVal = ScriptEngineKeywordDb((PUINT64)GetValue(GuestRegs, Src0));
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-  case FUNC_NEG:
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+		return;
+	case FUNC_DW:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-    DesVal = -(INT64)SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+		DesVal = ScriptEngineKeywordDb((PUINT64)GetValue(GuestRegs, Src0));
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
 
-    return;
+		return;
+	case FUNC_DQ:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
 
-  case FUNC_HI:
-    // TODO: Hanlde hi function
-    printf("Error: HI functions is not handled yet.\n");
+		DesVal = ScriptEngineKeywordDq((PUINT64)GetValue(GuestRegs, Src0));
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
 
-    return;
+	case FUNC_STR:
+		// TODO: Hanlde str function
+		printf("Error: STR functions is not handled yet.\n");
 
-  case FUNC_LOW:
-    // TODO: Hanlde low function
-    printf("Error: LOW functions is not handled yet.\n");
+		return;
 
-    return;
+	case FUNC_WSTR:
+		// TODO: Hanlde wstr function
+		printf("Error: WSTR functions is not handled yet.\n");
 
-  case FUNC_MOV:
-    Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
-                    (unsigned long long)(Indx * sizeof(SYMBOL)));
-    Indx++;
+		return;
 
-    DesVal = SrcVal0;
-    SetValue(GuestRegs, Des, DesVal);
-    printf("DesVal = %d\n", DesVal);
+	case FUNC_SIZEOF:
+		// TODO: Hanlde sizeof function because we do not support pdb so 
+		// we don't have support this function
+		printf("Error: DB functions is not handled yet.\n");
 
-    return;
-  }
+		return;
+
+	case FUNC_NOT:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = ~SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
+
+	case FUNC_NEG:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = -(INT64)SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
+
+	case FUNC_HI:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = ScriptEngineKeywordHi((PUINT64)GetValue(GuestRegs, Src0));
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
+
+	case FUNC_LOW:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = ScriptEngineKeywordLow((PUINT64)GetValue(GuestRegs, Src0));
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
+	case FUNC_MOV:
+		Des = (PSYMBOL)((unsigned long long)CodeBuffer->Head +
+			(unsigned long long)(Indx * sizeof(SYMBOL)));
+		Indx++;
+
+		DesVal = SrcVal0;
+		SetValue(GuestRegs, Des, DesVal);
+		printf("DesVal = %d\n", DesVal);
+
+		return;
+	}
 }
 //
 // test function
@@ -594,55 +574,55 @@ VOID ScriptEngineExecute(PGUEST_REGS GuestRegs, PSYMBOL_BUFFER CodeBuffer,
 
 VOID PerformAction(PGUEST_REGS GuestRegs, string Expr) {
 
-  //
-  // Test Parser
-  //
-  PSYMBOL_BUFFER CodeBuffer = ScriptEngineParse((char *)Expr.c_str());
+	//
+	// Test Parser
+	//
+	PSYMBOL_BUFFER CodeBuffer = ScriptEngineParse((char*)Expr.c_str());
 
-  PrintSymbolBuffer(CodeBuffer);
+	PrintSymbolBuffer(CodeBuffer);
 
-  for (int i = 0; i < CodeBuffer->Pointer;) {
-    printf("%d\n", i);
+	for (int i = 0; i < CodeBuffer->Pointer;) {
+		printf("%d\n", i);
 
-    ScriptEngineExecute(GuestRegs, CodeBuffer, i);
-  }
+		ScriptEngineExecute(GuestRegs, CodeBuffer, i);
+	}
 
-  RemoveSymbolBuffer(CodeBuffer);
+	RemoveSymbolBuffer(CodeBuffer);
 }
 
 VOID TestParser(string Expr) {
 
-  typedef struct _TEST_STRUCT {
-    UINT64 Var1;
-    UINT64 Var2;
-    UINT64 Var3;
-    UINT64 Var4;
-  } TEST_STRUCT, *PTEST_STRUCT;
+	typedef struct _TEST_STRUCT {
+		UINT64 Var1;
+		UINT64 Var2;
+		UINT64 Var3;
+		UINT64 Var4;
+	} TEST_STRUCT, * PTEST_STRUCT;
 
-  PTEST_STRUCT TestStruct = (PTEST_STRUCT)malloc(sizeof(TEST_STRUCT));
-  RtlZeroMemory(TestStruct, sizeof(TEST_STRUCT));
+	PTEST_STRUCT TestStruct = (PTEST_STRUCT)malloc(sizeof(TEST_STRUCT));
+	RtlZeroMemory(TestStruct, sizeof(TEST_STRUCT));
 
-  TestStruct->Var1 = 0x41414141;
-  TestStruct->Var3 = 0x4242424242424242;
+	TestStruct->Var1 = 0x41414141;
+	TestStruct->Var3 = 0x4242424242424242;
 
-  GUEST_REGS GuestRegs = {0};
+	GUEST_REGS GuestRegs = { 0 };
 
-  GuestRegs.rax = 0x1;
-  GuestRegs.rcx = (UINT64)TestStruct;
-  GuestRegs.rdx = 0x3;
-  GuestRegs.rbx = 0x4;
-  GuestRegs.rsp = 0x5;
-  GuestRegs.rbp = 0x6;
-  GuestRegs.rsi = 0x7;
-  GuestRegs.rdi = 0x8;
-  GuestRegs.r8 = 0x9;
-  GuestRegs.r9 = 0xa;
-  GuestRegs.r10 = 0xb;
-  GuestRegs.r11 = 0xc;
-  GuestRegs.r12 = 0xd;
-  GuestRegs.r13 = 0xe;
-  GuestRegs.r14 = 0xf;
-  GuestRegs.r15 = 0x10;
+	GuestRegs.rax = 0x1;
+	GuestRegs.rcx = (UINT64)TestStruct;
+	GuestRegs.rdx = 0x3;
+	GuestRegs.rbx = 0x4;
+	GuestRegs.rsp = 0x5;
+	GuestRegs.rbp = 0x6;
+	GuestRegs.rsi = 0x7;
+	GuestRegs.rdi = 0x8;
+	GuestRegs.r8 = 0x9;
+	GuestRegs.r9 = 0xa;
+	GuestRegs.r10 = 0xb;
+	GuestRegs.r11 = 0xc;
+	GuestRegs.r12 = 0xd;
+	GuestRegs.r13 = 0xe;
+	GuestRegs.r14 = 0xf;
+	GuestRegs.r15 = 0x10;
 
-  PerformAction(&GuestRegs, Expr);
+	PerformAction(&GuestRegs, Expr);
 }
diff --git a/hyperdbg/include/ScriptEngineCommon.h b/hyperdbg/include/ScriptEngineCommon.h
index 3c323015..d68041cf 100644
--- a/hyperdbg/include/ScriptEngineCommon.h
+++ b/hyperdbg/include/ScriptEngineCommon.h
@@ -21,3 +21,65 @@ typedef struct SYMBOL_BUFFER {
   unsigned int Size;
 
 } SYMBOL_BUFFER, *PSYMBOL_BUFFER;
+
+#define FUNC_OR 0
+#define FUNC_XOR 1
+#define FUNC_AND 2
+#define FUNC_ASR 3
+#define FUNC_ASL 4
+#define FUNC_ADD 5
+#define FUNC_SUB 6
+#define FUNC_MUL 7
+#define FUNC_DIV 8
+#define FUNC_MOD 9
+#define FUNC_POI 10
+#define FUNC_DB 11
+#define FUNC_DD 12
+#define FUNC_DW 13
+#define FUNC_DQ 14
+#define FUNC_STR 15
+#define FUNC_WSTR 16
+#define FUNC_SIZEOF 17
+#define FUNC_NOT 18
+#define FUNC_NEG 19
+#define FUNC_HI 20
+#define FUNC_LOW 21
+#define FUNC_MOV 22
+
+#define SYMBOL_ID_TYPE 0
+#define SYMBOL_NUM_TYPE 1
+#define SYMBOL_REGISTER_TYPE 2
+#define SYMBOL_PSEUDO_REG_TYPE 3
+#define SYMBOL_SEMANTIC_RULE_TYPE 4
+#define SYMBOL_TEMP_TYPE 5
+
+#define RAX_MNEMONIC 0
+#define RCX_MNEMONIC 1
+#define RDX_MNEMONIC 2
+#define RBX_MNEMONIC 3
+#define RSP_MNEMONIC 4
+#define RBP_MNEMONIC 5
+#define RSI_MNEMONIC 6
+#define RDI_MNEMONIC 7
+#define R8_MNEMONIC 8
+#define R9_MNEMONIC 9
+#define R10_MNEMONIC 10
+#define R11_MNEMONIC 11
+#define R12_MNEMONIC 12
+#define R13_MNEMONIC 13
+#define R14_MNEMONIC 14
+#define R15_MNEMONIC 15
+
+#define INVALID -1
+
+#define TID_MNEMONIC 0
+#define PID_MNEMONIC 1
+
+
+#define SYMBOL_ID_TYPE  0
+#define SYMBOL_NUM_TYPE 1
+#define SYMBOL_REGISTER_TYPE 2
+#define SYMBOL_PSEUDO_REG_TYPE 3
+#define SYMBOL_SEMANTIC_RULE_TYPE 4
+#define SYMBOL_TEMP 5
+
diff --git a/hyperdbg/script-engine/src/ScriptEngine.c b/hyperdbg/script-engine/src/ScriptEngine.c
index e6c7dc82..cfa68415 100644
--- a/hyperdbg/script-engine/src/ScriptEngine.c
+++ b/hyperdbg/script-engine/src/ScriptEngine.c
@@ -134,6 +134,10 @@ PSYMBOL_BUFFER ScriptEngineParse(char *str)
             }
             else
             {
+
+                free(CurrentIn->Value);
+                free(CurrentIn);
+
                 CurrentIn = Scan(str, &c);
                 printf("\nCurrent Input :\n");
                 PrintToken(CurrentIn);
@@ -150,7 +154,7 @@ PSYMBOL_BUFFER ScriptEngineParse(char *str)
 #endif
 
     } while (TopToken->Type != END_OF_STACK);
-  
+    
     return CodeBuffer;
 }
 
diff --git a/hyperdbg/script-engine/src/ScriptEngine.h b/hyperdbg/script-engine/src/ScriptEngine.h
index 78c0ba51..bb4d473a 100644
--- a/hyperdbg/script-engine/src/ScriptEngine.h
+++ b/hyperdbg/script-engine/src/ScriptEngine.h
@@ -1,7 +1,7 @@
 /**
  * @file ScriptEngine.h
  * @author M.H. Gholamrezei (gholamrezaei.mh@gmail.com)
- * @brief Script engine parser and codegen 
+ * @brief Script engine parser and codegen
  * @details
  * @version 0.1
  * @date 2020-10-22
@@ -20,61 +20,6 @@
 
  //#define _SCRIPT_ENGINE_DBG_EN
 
-#define SYMBOL_ID_TYPE  0
-#define SYMBOL_NUM_TYPE 1
-#define SYMBOL_REGISTER_TYPE 2
-#define SYMBOL_PSEUDO_REG_TYPE 3
-#define SYMBOL_SEMANTIC_RULE_TYPE 4
-#define SYMBOL_TEMP 5
-
-
-#define RAX_MNEMONIC 0
-#define RCX_MNEMONIC 1
-#define RDX_MNEMONIC 2
-#define RBX_MNEMONIC 3
-#define RSP_MNEMONIC 4
-#define RBP_MNEMONIC 5
-#define RSI_MNEMONIC 6
-#define RDI_MNEMONIC 7
-#define R8_MNEMONIC 8
-#define R9_MNEMONIC 9
-#define R10_MNEMONIC 10
-#define R11_MNEMONIC 11
-#define R12_MNEMONIC 12
-#define R13_MNEMONIC 13
-#define R14_MNEMONIC 14
-#define R15_MNEMONIC 15
-
-#define INVALID -1
-
-#define TID_MNEMONIC 0
-#define PID_MNEMONIC 1
-
-
-
-#define FUNC_OR 0
-#define FUNC_XOR 1
-#define FUNC_AND 2
-#define FUNC_ASR 3
-#define FUNC_ASL 4
-#define FUNC_ADD 5
-#define FUNC_SUB 6
-#define FUNC_MUL 7
-#define FUNC_DIV 8
-#define FUNC_MOD 9
-#define FUNC_POI 10
-#define FUNC_DB 11
-#define FUNC_DD 12
-#define FUNC_DW 13
-#define FUNC_DQ 14
-#define FUNC_STR 15
-#define FUNC_WSTR 16
-#define FUNC_SIZEOF 17
-#define FUNC_NOT 18
-#define FUNC_NEG 19
-#define FUNC_HI 20
-#define FUNC_LOW 21
-#define FUNC_MOV 22
 
 
 #define SYMBOL_BUFFER_INIT_SIZE 1024
@@ -102,7 +47,7 @@ unsigned int IdCounter = 0;
 
 
 char IsNoneTerminal(TOKEN Token);
-char IsSemanticRule(TOKEN Token); 
+char IsSemanticRule(TOKEN Token);
 char IsEqual(const TOKEN Token1, const TOKEN Token2);
 
 int GetNonTerminalId(TOKEN Token);
diff --git a/hyperdbg/script-engine/src/scanner.c b/hyperdbg/script-engine/src/scanner.c
index b9315ec8..32cf74d5 100644
--- a/hyperdbg/script-engine/src/scanner.c
+++ b/hyperdbg/script-engine/src/scanner.c
@@ -18,675 +18,675 @@
 
 const char* KeywordList[] =
 {
-    "str",
-    "low",
-    "poi",
-    "db",
-    "dq",
-    "dw",
-    "not",
-    "dd",
-    "func",
-    "wstr",
-    "sizeof",
-    "neg",
-    "hi"
+	"str",
+	"low",
+	"poi",
+	"db",
+	"dq",
+	"dw",
+	"not",
+	"dd",
+	"func",
+	"wstr",
+	"sizeof",
+	"neg",
+	"hi"
 };
 
 /**
- * 
+ *
  */
 TOKEN NewToken()
 {
-    TOKEN Token;
-    Token = (TOKEN)malloc(sizeof(*Token));
-    Token->Value = (char *)calloc(TOKEN_VALUE_MAX_LEN, sizeof(char));
-    strcpy(Token->Value, "");
-    Token->Type = UNKNOWN;
-    return Token;
+	TOKEN Token;
+	Token = (TOKEN)malloc(sizeof(*Token));
+	Token->Value = (char*)calloc(TOKEN_VALUE_MAX_LEN, sizeof(char));
+	strcpy(Token->Value, "");
+	Token->Type = UNKNOWN;
+	return Token;
 }
 
 /**
- * 
+ *
  */
 TOKEN_LIST NewTokenList(void)
 {
-    TOKEN_LIST TokenList;
-    TokenList = (TOKEN_LIST)malloc(sizeof(*TokenList));
-    TokenList->Pointer = 0;
-    TokenList->Size = TOKEN_LIST_INIT_SIZE;
-    TokenList->Head = (TOKEN *)malloc(TokenList->Size * sizeof(TOKEN));
-    return TokenList;
+	TOKEN_LIST TokenList;
+	TokenList = (TOKEN_LIST)malloc(sizeof(*TokenList));
+	TokenList->Pointer = 0;
+	TokenList->Size = TOKEN_LIST_INIT_SIZE;
+	TokenList->Head = (TOKEN*)malloc(TokenList->Size * sizeof(TOKEN));
+	return TokenList;
 }
 
 /**
- * 
+ *
  */
 TOKEN_LIST Push(TOKEN_LIST TokenList, TOKEN Token)
 {
-    //
-    // Calculate address to write new token
-    //
-    uintptr_t Head = (uintptr_t)TokenList->Head;
-    uintptr_t Pointer = (uintptr_t)TokenList->Pointer;
-    TOKEN *WriteAddr = (TOKEN *)(Head + Pointer * sizeof(TOKEN));
+	//
+	// Calculate address to write new token
+	//
+	uintptr_t Head = (uintptr_t)TokenList->Head;
+	uintptr_t Pointer = (uintptr_t)TokenList->Pointer;
+	TOKEN* WriteAddr = (TOKEN*)(Head + Pointer * sizeof(TOKEN));
 
-    //
-    // Write Token to appropriate address in TokenList
-    //
-    *WriteAddr = Token;
+	//
+	// Write Token to appropriate address in TokenList
+	//
+	*WriteAddr = Token;
 
-    //
-    // Update Pointer
-    //
-    TokenList->Pointer++;
+	//
+	// Update Pointer
+	//
+	TokenList->Pointer++;
 
-    //
-    // Handle overflow
-    //
-    if (Pointer == TokenList->Size - 1)
-    {
-        //
-        // Allocate a new buffer for string list with doubled length
-        //
-        TOKEN *NewHead = (TOKEN *)malloc(2 * TokenList->Size * sizeof(TOKEN));
+	//
+	// Handle overflow
+	//
+	if (Pointer == TokenList->Size - 1)
+	{
+		//
+		// Allocate a new buffer for string list with doubled length
+		//
+		TOKEN* NewHead = (TOKEN*)malloc(2 * TokenList->Size * sizeof(TOKEN));
 
-        //
-        // Copy old buffer to new buffer
-        //
-        memcpy(NewHead, TokenList->Head, TokenList->Size * sizeof(TOKEN));
+		//
+		// Copy old buffer to new buffer
+		//
+		memcpy(NewHead, TokenList->Head, TokenList->Size * sizeof(TOKEN));
 
-        //
-        // Free old buffer
-        //
-        free(TokenList->Head);
+		//
+		// Free old buffer
+		//
+		free(TokenList->Head);
 
-        //
-        // Update Head and size of TokenList
-        //
-        TokenList->Size = TokenList->Size * 2;
-        TokenList->Head = NewHead;
-    }
+		//
+		// Update Head and size of TokenList
+		//
+		TokenList->Size = TokenList->Size * 2;
+		TokenList->Head = NewHead;
+	}
 
-    return TokenList;
+	return TokenList;
 }
 /**
- * 
+ *
  */
- 
+
 TOKEN Pop(TOKEN_LIST TokenList)
 {
-    //
-    // Calculate address to read most recent token
-    //
-    if (TokenList->Pointer > 0)
-        TokenList->Pointer--;
-    uintptr_t Head = (uintptr_t)TokenList->Head;
-    uintptr_t Pointer = (uintptr_t)TokenList->Pointer;
-    TOKEN *ReadAddr = (TOKEN *)(Head + Pointer * sizeof(TOKEN));
+	//
+	// Calculate address to read most recent token
+	//
+	if (TokenList->Pointer > 0)
+		TokenList->Pointer--;
+	uintptr_t Head = (uintptr_t)TokenList->Head;
+	uintptr_t Pointer = (uintptr_t)TokenList->Pointer;
+	TOKEN* ReadAddr = (TOKEN*)(Head + Pointer * sizeof(TOKEN));
 
-    
-    return *ReadAddr;
+
+	return *ReadAddr;
 }
 
 TOKEN Top(TOKEN_LIST TokenList)
 {
-    //
-    // Calculate address to read most recent token
-    //
-    uintptr_t Head = (uintptr_t)TokenList->Head;
-    uintptr_t Pointer = (uintptr_t)TokenList->Pointer-1;
-    TOKEN *ReadAddr = (TOKEN *)(Head + Pointer * sizeof(TOKEN));
+	//
+	// Calculate address to read most recent token
+	//
+	uintptr_t Head = (uintptr_t)TokenList->Head;
+	uintptr_t Pointer = (uintptr_t)TokenList->Pointer - 1;
+	TOKEN* ReadAddr = (TOKEN*)(Head + Pointer * sizeof(TOKEN));
 
-    return *ReadAddr;
+	return *ReadAddr;
 }
 /**
- * 
+ *
  */
 void PrintTokenList(TOKEN_LIST TokenList)
 {
-    TOKEN Token = NewToken();
-    for (uintptr_t i = 0; i < TokenList->Pointer; i++)
-    {
-        Token = *(TokenList->Head + i);
-        PrintToken(Token);
-    }
+	TOKEN Token = NewToken();
+	for (uintptr_t i = 0; i < TokenList->Pointer; i++)
+	{
+		Token = *(TokenList->Head + i);
+		PrintToken(Token);
+	}
 }
 
 /**
- * 
- * 
+ *
+ *
  */
 void PrintToken(TOKEN Token)
 {
-    if (Token->Type == WHITE_SPACE)
-    {
-        printf("< :");
-    }
-    else
-    {
-        printf("<'%s' : ", Token->Value);
-    }
+	if (Token->Type == WHITE_SPACE)
+	{
+		printf("< :");
+	}
+	else
+	{
+		printf("<'%s' : ", Token->Value);
+	}
 
-    switch (Token->Type)
-    {
-    case ID:
-        printf(" ID>\n");
-        break;
-    case DECIMAL:
-        printf(" DECIMAL>\n");
-        break;
-    case HEX:
-        printf(" HEX>\n");
-        break;
-    case OCTAL:
-        printf(" OCTAL>\n");
-        break;
-    case BINARY:
-        printf(" BINARY>\n");
-        break;
-    case SPECIAL_TOKEN:
-        printf(" SPECIAL_TOKEN>\n");
-        break;
-    case KEYWORD:
-        printf(" KEYWORD>\n");
-        break;
-    case WHITE_SPACE:
-        printf(" WHITE_SPACE>\n");
-        break;
-    case COMMENT:
-        printf(" COMMENT>\n");
-        break;
-    case REGISTER:
-        printf(" REGISTER>\n");
-        break;
-    case PSEUDO_REGISTER:
-        printf(" PSEUDO_REGISTER>\n");
-        break;
-    case SEMANTIC_RULE:
-        printf(" SEMANTIC_RULE>\n");
-        break;
-    case NON_TERMINAL:
-        printf(" NON_TERMINAL>\n");
-        break;
-    case END_OF_STACK:
-        printf(" END_OF_STACK>\n");
-        break;
-    case UNKNOWN:
-        printf(" UNKNOWN>\n");
-        break;
+	switch (Token->Type)
+	{
+	case ID:
+		printf(" ID>\n");
+		break;
+	case DECIMAL:
+		printf(" DECIMAL>\n");
+		break;
+	case HEX:
+		printf(" HEX>\n");
+		break;
+	case OCTAL:
+		printf(" OCTAL>\n");
+		break;
+	case BINARY:
+		printf(" BINARY>\n");
+		break;
+	case SPECIAL_TOKEN:
+		printf(" SPECIAL_TOKEN>\n");
+		break;
+	case KEYWORD:
+		printf(" KEYWORD>\n");
+		break;
+	case WHITE_SPACE:
+		printf(" WHITE_SPACE>\n");
+		break;
+	case COMMENT:
+		printf(" COMMENT>\n");
+		break;
+	case REGISTER:
+		printf(" REGISTER>\n");
+		break;
+	case PSEUDO_REGISTER:
+		printf(" PSEUDO_REGISTER>\n");
+		break;
+	case SEMANTIC_RULE:
+		printf(" SEMANTIC_RULE>\n");
+		break;
+	case NON_TERMINAL:
+		printf(" NON_TERMINAL>\n");
+		break;
+	case END_OF_STACK:
+		printf(" END_OF_STACK>\n");
+		break;
+	case UNKNOWN:
+		printf(" UNKNOWN>\n");
+		break;
 
-    default:
-        printf(" ERROR>\n");
-        break;
-    }
+	default:
+		printf(" ERROR>\n");
+		break;
+	}
 }
 /**
- * 
+ *
  */
 void Append(TOKEN Token, char c)
 {
-    strncat(Token->Value, &c, 1);
+	strncat(Token->Value, &c, 1);
 }
 /**
- * 
+ *
  */
-TOKEN GetToken(char *c, char* str)
+TOKEN GetToken(char* c, char* str)
 {
-    static unsigned char WaitForID = 1;
-    TOKEN Token = NewToken();
+	static unsigned char WaitForID = 1;
+	TOKEN Token = NewToken();
 
-    switch (*c)
-    {
-    case '+':
-        *c = sgetc(str);
-        if (*c == '+')
-        {
-            strcpy(Token->Value, "++");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else if (*c == '=')
-        {
-            strcpy(Token->Value, "+=");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else
-        {
-            strcpy(Token->Value, "+");
-            Token->Type = SPECIAL_TOKEN;
-            return Token;
-        }
-    case '-':
-        *c = sgetc(str);
-        if (*c == '-')
-        {
-            strcpy(Token->Value, "--");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else if (*c == '=')
-        {
-            strcpy(Token->Value, "-=");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else
-        {
-            strcpy(Token->Value, "-");
-            Token->Type = SPECIAL_TOKEN;
-            return Token;
-        }
-    case '*':
-        *c = sgetc(str);
-        if (*c == '=')
-        {
-            strcpy(Token->Value, "*=");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else
-        {
-            strcpy(Token->Value, "*");
-            Token->Type = SPECIAL_TOKEN;
-            return Token;
-        }
-    case '>':
-        *c = sgetc(str);
-        if (*c == '>')
-        {
-            strcpy(Token->Value, ">>");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else
-        {
-            strcpy(Token->Value, ">");
-            Token->Type = SPECIAL_TOKEN;
-            return Token;
-        }
-    case '<':
-        *c = sgetc(str);
-        if (*c == '<')
-        {
-            strcpy(Token->Value, "<<");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else
-        {
-            strcpy(Token->Value, "<");
-            Token->Type = SPECIAL_TOKEN;
-            return Token;
-        }
-    case '/':
-        *c = sgetc(str);
-        if (*c == '=')
-        {
-            strcpy(Token->Value, "/=");
-            Token->Type = SPECIAL_TOKEN;
-            *c = sgetc(str);
+	switch (*c)
+	{
+	case '+':
+		*c = sgetc(str);
+		if (*c == '+')
+		{
+			strcpy(Token->Value, "++");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else if (*c == '=')
+		{
+			strcpy(Token->Value, "+=");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else
+		{
+			strcpy(Token->Value, "+");
+			Token->Type = SPECIAL_TOKEN;
+			return Token;
+		}
+	case '-':
+		*c = sgetc(str);
+		if (*c == '-')
+		{
+			strcpy(Token->Value, "--");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else if (*c == '=')
+		{
+			strcpy(Token->Value, "-=");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else
+		{
+			strcpy(Token->Value, "-");
+			Token->Type = SPECIAL_TOKEN;
+			return Token;
+		}
+	case '*':
+		*c = sgetc(str);
+		if (*c == '=')
+		{
+			strcpy(Token->Value, "*=");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else
+		{
+			strcpy(Token->Value, "*");
+			Token->Type = SPECIAL_TOKEN;
+			return Token;
+		}
+	case '>':
+		*c = sgetc(str);
+		if (*c == '>')
+		{
+			strcpy(Token->Value, ">>");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else
+		{
+			strcpy(Token->Value, ">");
+			Token->Type = SPECIAL_TOKEN;
+			return Token;
+		}
+	case '<':
+		*c = sgetc(str);
+		if (*c == '<')
+		{
+			strcpy(Token->Value, "<<");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else
+		{
+			strcpy(Token->Value, "<");
+			Token->Type = SPECIAL_TOKEN;
+			return Token;
+		}
+	case '/':
+		*c = sgetc(str);
+		if (*c == '=')
+		{
+			strcpy(Token->Value, "/=");
+			Token->Type = SPECIAL_TOKEN;
+			*c = sgetc(str);
 
-            return Token;
-        }
-        else if (*c == '/')
-        {
-            do
-            {
-                *c = sgetc(str);
-            } while (*c != '\n' && *c != EOF);
+			return Token;
+		}
+		else if (*c == '/')
+		{
+			do
+			{
+				*c = sgetc(str);
+			} while (*c != '\n' && *c != EOF);
 
-            Token->Type = COMMENT;
-            *c = sgetc(str);
-            return Token;
-        }
-        else if (*c == '*')
-        {
-            do
-            {
-                *c = sgetc(str);
-                if (*c == '*')
-                {
-                    *c = sgetc(str);
-                    if (*c == '/')
-                    {
-                        Token->Type = COMMENT;
-                        *c = sgetc(str);
-                        return Token;
-                    }
-                }
-                if (*c == EOF)
-                    break;
-            } while (1);
+			Token->Type = COMMENT;
+			*c = sgetc(str);
+			return Token;
+		}
+		else if (*c == '*')
+		{
+			do
+			{
+				*c = sgetc(str);
+				if (*c == '*')
+				{
+					*c = sgetc(str);
+					if (*c == '/')
+					{
+						Token->Type = COMMENT;
+						*c = sgetc(str);
+						return Token;
+					}
+				}
+				if (*c == EOF)
+					break;
+			} while (1);
 
-            Token->Type = UNKNOWN;
-            *c = sgetc(str);
-            return Token;
-        }
-        else
-        {
-            strcpy(Token->Value, "/");
-            Token->Type = SPECIAL_TOKEN;
-            return Token;
-        }
+			Token->Type = UNKNOWN;
+			*c = sgetc(str);
+			return Token;
+		}
+		else
+		{
+			strcpy(Token->Value, "/");
+			Token->Type = SPECIAL_TOKEN;
+			return Token;
+		}
 
-    case '=':
-        strcpy(Token->Value, "=");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case '%':
-        strcpy(Token->Value, "%");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
+	case '=':
+		strcpy(Token->Value, "=");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case '%':
+		strcpy(Token->Value, "%");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
 
-    case ',':
-        strcpy(Token->Value, ",");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
+	case ',':
+		strcpy(Token->Value, ",");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
 
-    case ';':
-        strcpy(Token->Value, ";");
-        Token->Type = SPECIAL_TOKEN;
-        WaitForID = 1;
-        *c = sgetc(str);
-        return Token;
+	case ';':
+		strcpy(Token->Value, ";");
+		Token->Type = SPECIAL_TOKEN;
+		WaitForID = 1;
+		*c = sgetc(str);
+		return Token;
 
-    case ':':
-        strcpy(Token->Value, ":");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
+	case ':':
+		strcpy(Token->Value, ":");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
 
-    case '(':
-        strcpy(Token->Value, "(");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case ')':
-        strcpy(Token->Value, ")");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case '{':
-        strcpy(Token->Value, "{");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case '}':
-        strcpy(Token->Value, "}");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case '|':
-        strcpy(Token->Value, "|");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case '&':
-        strcpy(Token->Value, "&");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case '^':
-        strcpy(Token->Value, "^");
-        Token->Type = SPECIAL_TOKEN;
-        *c = sgetc(str);
-        return Token;
-    case '@':
-        *c = sgetc(str);
-        if (IsLetter(*c))
-        {
-            while (IsLetter(*c) || IsDecimal(*c))
-            {
-                Append(Token, *c);
-                *c = sgetc(str);
-            }
-            Token->Type = REGISTER;
-            return Token;
-        }
+	case '(':
+		strcpy(Token->Value, "(");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case ')':
+		strcpy(Token->Value, ")");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case '{':
+		strcpy(Token->Value, "{");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case '}':
+		strcpy(Token->Value, "}");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case '|':
+		strcpy(Token->Value, "|");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case '&':
+		strcpy(Token->Value, "&");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case '^':
+		strcpy(Token->Value, "^");
+		Token->Type = SPECIAL_TOKEN;
+		*c = sgetc(str);
+		return Token;
+	case '@':
+		*c = sgetc(str);
+		if (IsLetter(*c))
+		{
+			while (IsLetter(*c) || IsDecimal(*c))
+			{
+				Append(Token, *c);
+				*c = sgetc(str);
+			}
+			Token->Type = REGISTER;
+			return Token;
+		}
 
-    case '$':
-        *c = sgetc(str);
-        if (IsLetter(*c))
-        {
-            while (IsLetter(*c) || IsDecimal(*c))
-            {
-                Append(Token, *c);
-                *c = sgetc(str);
-            }
-            Token->Type = PSEUDO_REGISTER;
-            return Token;
-        }
+	case '$':
+		*c = sgetc(str);
+		if (IsLetter(*c))
+		{
+			while (IsLetter(*c) || IsDecimal(*c))
+			{
+				Append(Token, *c);
+				*c = sgetc(str);
+			}
+			Token->Type = PSEUDO_REGISTER;
+			return Token;
+		}
 
-    case '.':
-        *c = sgetc(str);
-        if (IsHex(*c))
-        {
-        }
-        else
-        {
-        }
+	case '.':
+		*c = sgetc(str);
+		if (IsHex(*c))
+		{
+		}
+		else
+		{
+		}
 
-    case ' ':
-    case '\t':
-        strcpy(Token->Value, "");
-        Token->Type = WHITE_SPACE;
-        *c = sgetc(str);
-        return Token;
-    case '\n':
-        strcpy(Token->Value, "");
-        Token->Type = WHITE_SPACE;
-        *c = sgetc(str);
-        WaitForID = 1;
-        return Token;
+	case ' ':
+	case '\t':
+		strcpy(Token->Value, "");
+		Token->Type = WHITE_SPACE;
+		*c = sgetc(str);
+		return Token;
+	case '\n':
+		strcpy(Token->Value, "");
+		Token->Type = WHITE_SPACE;
+		*c = sgetc(str);
+		WaitForID = 1;
+		return Token;
 
-    case '0':
-        *c = sgetc(str);
-        if (*c == 'x')
-        {
-            *c = sgetc(str);
-            while (IsHex(*c) || *c == '`')
-            {
-                if (*c != '`')
-                    Append(Token, *c);
-                *c = sgetc(str);
-            }
-            Token->Type = HEX;
-            return Token;
-        }
-        else if (*c == 'o')
-        {
-            *c = sgetc(str);
-            while (IsOctal(*c) || *c == '`')
-            {
-                if (*c != '`')
-                    Append(Token, *c);
-                *c = sgetc(str);
-            }
-            Token->Type = OCTAL;
-            return Token;
-        }
-        else if (*c == 'n')
-        {
-            *c = sgetc(str);
-            while (IsDecimal(*c) || *c == '`')
-            {
-                if (*c != '`')
-                    Append(Token, *c);
-                *c = sgetc(str);
-            }
-            Token->Type = DECIMAL;
-            return Token;
-        }
-        else if (*c == 'y')
-        {
-            *c = sgetc(str);
-            while (IsBinary(*c) || *c == '`')
-            {
-                if (*c != '`')
-                    Append(Token, *c);
-                *c = sgetc(str);
-            }
-            Token->Type = BINARY;
-            return Token;
-        }
+	case '0':
+		*c = sgetc(str);
+		if (*c == 'x')
+		{
+			*c = sgetc(str);
+			while (IsHex(*c) || *c == '`')
+			{
+				if (*c != '`')
+					Append(Token, *c);
+				*c = sgetc(str);
+			}
+			Token->Type = HEX;
+			return Token;
+		}
+		else if (*c == 'o')
+		{
+			*c = sgetc(str);
+			while (IsOctal(*c) || *c == '`')
+			{
+				if (*c != '`')
+					Append(Token, *c);
+				*c = sgetc(str);
+			}
+			Token->Type = OCTAL;
+			return Token;
+		}
+		else if (*c == 'n')
+		{
+			*c = sgetc(str);
+			while (IsDecimal(*c) || *c == '`')
+			{
+				if (*c != '`')
+					Append(Token, *c);
+				*c = sgetc(str);
+			}
+			Token->Type = DECIMAL;
+			return Token;
+		}
+		else if (*c == 'y')
+		{
+			*c = sgetc(str);
+			while (IsBinary(*c) || *c == '`')
+			{
+				if (*c != '`')
+					Append(Token, *c);
+				*c = sgetc(str);
+			}
+			Token->Type = BINARY;
+			return Token;
+		}
 
-        else if (IsHex(*c))
-        {
-            do
-            {
-                if (*c != '`')
-                    Append(Token, *c);
-                *c = sgetc(str);
-            } while (IsHex(*c) || *c == '`');
-            Token->Type = HEX;
-            return Token;
-        }
-        else
-        {
-            strcpy(Token->Value, "0");
-            Token->Type = HEX;
-            return Token;
-        }
+		else if (IsHex(*c))
+		{
+			do
+			{
+				if (*c != '`')
+					Append(Token, *c);
+				*c = sgetc(str);
+			} while (IsHex(*c) || *c == '`');
+			Token->Type = HEX;
+			return Token;
+		}
+		else
+		{
+			strcpy(Token->Value, "0");
+			Token->Type = HEX;
+			return Token;
+		}
 
-    default:
-        if (IsHex(*c))
-        {
-            do
-            {
-                if (*c != '`')
-                    Append(Token, *c);
-                *c = sgetc(str);
-            } while (IsHex(*c) || *c == '`');
-            int n = sizeof(KeywordList) / sizeof(char*);
-            for (int i = 0; i < n; i++)
-            {
-                if (!strcmp(Token->Value, KeywordList[i]))
-                {
-                    Token->Type = KEYWORD;
-                    return Token;
-                }
-            }
-            Token->Type = HEX;
-            return Token;
-        }
-        else if (IsLetter(*c) || *c == '_')
-        {
-            while (IsLetter(*c) || *c == '_' || IsDecimal(*c))
-            {
-                Append(Token, *c);
-                *c = sgetc(str);
-            }
+	default:
+		if (IsHex(*c))
+		{
+			do
+			{
+				if (*c != '`')
+					Append(Token, *c);
+				*c = sgetc(str);
+			} while (IsHex(*c) || *c == '`');
+			int n = sizeof(KeywordList) / sizeof(char*);
+			for (int i = 0; i < n; i++)
+			{
+				if (!strcmp(Token->Value, KeywordList[i]))
+				{
+					Token->Type = KEYWORD;
+					return Token;
+				}
+			}
+			Token->Type = HEX;
+			return Token;
+		}
+		else if (IsLetter(*c) || *c == '_')
+		{
+			while (IsLetter(*c) || *c == '_' || IsDecimal(*c))
+			{
+				Append(Token, *c);
+				*c = sgetc(str);
+			}
 
-            if (WaitForID)
-            {
-                Token->Type = ID;
-                WaitForID = 0;
-            }
-            else
-            {
-                Token->Type = KEYWORD;
-            }
+			if (WaitForID)
+			{
+				Token->Type = ID;
+				WaitForID = 0;
+			}
+			else
+			{
+				Token->Type = KEYWORD;
+			}
 
-            return Token;
-        }
-        
+			return Token;
+		}
 
-        Token->Type = UNKNOWN;
-        *c = sgetc(str);
-        return Token;
-    }
-    return Token;
+
+		Token->Type = UNKNOWN;
+		*c = sgetc(str);
+		return Token;
+	}
+	return Token;
 }
 /**
- * 
+ *
  */
 TOKEN Scan(char* str, char* c)
 {
-    TOKEN Token = NewToken();
+	TOKEN Token = NewToken();
 
-    while (1)
-    {
+	while (1)
+	{
 
-        Token = GetToken(c, str);
-        if (*c == EOF)
-        {
-            Token->Type = END_OF_STACK;
-            strcpy(Token->Value,"$");
-            return Token;
-        }            
-            
-        else if (Token->Type == WHITE_SPACE || Token->Type == COMMENT)
-        {
-            continue;
-        }  
-        return Token;
-    }
+		Token = GetToken(c, str);
+		if (*c == EOF)
+		{
+			Token->Type = END_OF_STACK;
+			strcpy(Token->Value, "$");
+			return Token;
+		}
+
+		else if (Token->Type == WHITE_SPACE || Token->Type == COMMENT)
+		{
+			continue;
+		}
+		return Token;
+	}
 }
 
 char IsHex(char c)
 {
-    if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
-        return 1;
-    else
-        return 0;
+	if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
+		return 1;
+	else
+		return 0;
 }
 char IsDecimal(char c)
 {
-    if (c >= '0' && c <= '9')
-        return 1;
-    else
-        return 0;
+	if (c >= '0' && c <= '9')
+		return 1;
+	else
+		return 0;
 }
 char IsLetter(char c)
 {
-    if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
-        return 1;
-    else
-    {
-        return 0;
-    }
+	if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
+		return 1;
+	else
+	{
+		return 0;
+	}
 }
 char IsBinary(char c)
 {
-    if (c == '0' || c == '1')
-        return 1;
-    else
-    {
-        return 0;
-    }
+	if (c == '0' || c == '1')
+		return 1;
+	else
+	{
+		return 0;
+	}
 }
 char IsOctal(char c)
 {
-    if (c >= '0' && c <= '7')
-        return 1;
-    else
-        return 0;
+	if (c >= '0' && c <= '7')
+		return 1;
+	else
+		return 0;
 }
 
 char sgetc(char* str)
 {
-    
 
-    char c = str[InputIdx];
-    if (c)
-    {
-        InputIdx++;
-        return c;
-    }
-    else
-    {
-        return EOF;
-    }
+
+	char c = str[InputIdx];
+	if (c)
+	{
+		InputIdx++;
+		return c;
+	}
+	else
+	{
+		return EOF;
+	}
 }
\ No newline at end of file
diff --git a/hyperdbg/script-engine/src/scanner.h b/hyperdbg/script-engine/src/scanner.h
index 7823c2b2..f437bcb0 100644
--- a/hyperdbg/script-engine/src/scanner.h
+++ b/hyperdbg/script-engine/src/scanner.h
@@ -13,57 +13,60 @@
 #define SCANNER_H
 #include <stdio.h>
 
-//#define SCRIPTENGINE_EXPORTS
+ //#define SCRIPTENGINE_EXPORTS
 #define TOKEN_VALUE_MAX_LEN 100
 #define TOKEN_LIST_INIT_SIZE 16
 typedef enum TOKEN_TYPE
 {
-    ID,
-    DECIMAL,
-    HEX,
-    OCTAL,
-    BINARY,
-    SPECIAL_TOKEN,
-    KEYWORD,
-    WHITE_SPACE,
-    COMMENT,
-    REGISTER,
-    PSEUDO_REGISTER,
-    NON_TERMINAL,
-    SEMANTIC_RULE,
-    END_OF_STACK,
-    EPSILON,
-    TEMP,
-    UNKNOWN
+	ID,
+	DECIMAL,
+	HEX,
+	OCTAL,
+	BINARY,
+	SPECIAL_TOKEN,
+	KEYWORD,
+	WHITE_SPACE,
+	COMMENT,
+	REGISTER,
+	PSEUDO_REGISTER,
+	NON_TERMINAL,
+	SEMANTIC_RULE,
+	END_OF_STACK,
+	EPSILON,
+	TEMP,
+	UNKNOWN
 } TOKEN_TYPE;
 
 
 struct _TOKEN
 {
-    TOKEN_TYPE Type;
-    char *Value;
+	TOKEN_TYPE Type;
+	char* Value;
 };
 
-typedef struct _TOKEN *TOKEN;
+typedef struct _TOKEN* TOKEN;
 
 typedef struct _TOKEN_LIST
 {
-    TOKEN *Head;
-    unsigned int Pointer;
-    unsigned int Size;
-} * TOKEN_LIST;
+	TOKEN* Head;
+	unsigned int Pointer;
+	unsigned int Size;
+} *TOKEN_LIST;
 
 unsigned int InputIdx;
 
 TOKEN NewToken(void);
+void RemoveToken(TOKEN Token);
+
 TOKEN_LIST NewTokenList(void);
+void RemoveTokenList(TOKEN_LIST TokenList);
 void PrintTokenList(TOKEN_LIST TokenList);
 void PrintToken(TOKEN Token);
 TOKEN_LIST Push(TOKEN_LIST TokenList, TOKEN Token);
 TOKEN Pop(TOKEN_LIST TokenList);
 TOKEN Top(TOKEN_LIST TokenList);
 void Append(TOKEN Token, char c);
-TOKEN GetToken(char *c, char* str);
+TOKEN GetToken(char* c, char* str);
 TOKEN Scan(char* str, char* c);
 char IsHex(char c);
 char IsDecimal(char c);