.gitignore

 transpiler
 *.o
-*.out
\ No newline at end of file
+*.out
+*.valgrind
\ No newline at end of file

Makefile

@@ -3,6 +3,9 @@ all: build
 build:
 	cd src && make
 
+pack:
+	cd src && zip ../Tema_1_Mihai_Popescu_312CA.zip *.c *.h Makefile
+
 clean:
 	cd src && make clean
 	rm -rf transpiler

README.md

-# Homework 1 
+# Homework 1
 
 ## Assignment: Simple C-to-Assembly Compiler
 
+**Deadline soft**: 6 aprilie 2025, 11:55PM
+
+**Deadline hard**: 11 aprilie 2025, 11:55PM
+
+**Authors**
+
+* Robert Grancsa
+* Adelina Alexe
+
+## Introduction
+![](banner.webp)
+
+In a neon-lit room filled with vintage circuit boards and digital memes, Alex—a modern TikTok brain rot specialist—devised a daring plan to escape Instagram’s endless scroll. Determined to reclaim his mind, he crafted a groundbreaking compiler that transformed addictive algorithms into streams of artful data. With every line of code, toxic noise became immersive stories, intricate music, and thought-provoking visuals, forging a digital sanctuary where creativity reigned. As the algorithmic chains broke, Alex emerged as a quiet revolutionary—a cyber alchemist turning the toxic into transcendent.
+
 ### Objective
 
 Develop a small compiler or translator that converts simple C-like code snippets into basic assembly instructions. The primary goal is to familiarize yourself with assembly language mnemonics and to understand how high-level constructs map to low-level operations. This assignment is intentionally minimalistic to ease you into both assembly language and compiler design. If we actually want to be pedantic, this is actually a [transpiler](https://en.wikipedia.org/wiki/Source-to-source_compiler) implementation.
@@ -13,22 +27,13 @@ The translation should be as simple as possible while covering basic arithmetic
 
 ## Conventions and Guidelines
 
-Because we want to prevent you from having to juggle with registers and allocate memory for vectors.
+Because we want to prevent you from having to juggle with registers, we'll use some simple conventions.
 
 - **Basic Register Mapping:**
   - `A` → `eax`
   - `B` → `ebx`
   - `C` → `ecx`
   - `D` → `edx`
-  - For vector (array) access, use `esi` (or `edi`), e.g., if `v = [1, 2, 3]`, the base address can be represented by a label like `$vec`.
-- **Array Notation:**
-  - Declaring an array: `v = [1, 2, 3]`  
-  - Accessing an element: `c = v[1]` should translate into something like:
-    ```
-    MOV esi, $vec    ; Load the base address of the vector
-    MOV ecx, [esi + 4] ; Load the second element (assuming 4 bytes per element)
-    ```
-  - When 
 - **Data types**
   - We'll assume all of the data types are **4 bytes**
   - When you see a number, we will treat it as a int (4 bytes)
@@ -66,7 +71,7 @@ The mov instructions is the simplest of all, and as the name says, it moves the
 | **C Code** 	    | **ASM Code**    |
 |------------	    |---------------- |
 | `a = a & 0xFF;`   | `AND eax, 0xFF` |
-| `b = a | b;`      | `OR ebx, eax`   |
+| `b = b \| a`      | `OR ebx, eax`   |
 | `c = a ^ c;`      | `XOR ecx, eax`  |
 
 ### Arithmetic operations
@@ -93,17 +98,27 @@ You might be wondering, why only one operand? Here we have a special rule, and g
 
 When multiplying with MUL, the multiplication will actually take EAX and source2 as the multiplication values, and set them in 2 registers -> EDX and EAX. EDX will store the higher values, and EAX the lower one, acting as a big 8 byte register, because after multiplying two 32 bit number, we might have an overflow. Looking at the table will make it a bit clearer.
 
+Similar to MUL, DIV works with EAX as the primary operand, but it also considers EDX as part of the dividend. This means the division is performed using a 64-bit value (EDX:EAX) divided by the given divisor. The result is stored in EAX, while the remainder is placed in EDX.
+
 | **C Code** 	    | **ASM Code**   	|
 |------------   	|----------------	|
 | `a = a * 3;`   	| `MUL 3`   	    |
-| `b = b * c;`      | `MOV eax, ebx`    |
-|                   | `MUL ecx`         |
-|                   | `MOV ebx, eax`    |
-
-The last 3 rows represent the second operation.
+| `b = b * c;`    | `MOV eax, ebx`  |
+|                 | `MUL ecx`       |
+|                 | `MOV ebx, eax`  |
+| `a = a / 3;`    | `MOV eax, a`    |
+|                 | `DIV 3`         |
+|                 | `MOV a, eax`    |
+| `b = b / c;`    | `MOV eax, ebx`  |
+|                 | `DIV ecx`       |
+|                 | `	MOV ebx, eax` |
 
 **Note**: For simplicity, we will never use eax as source2, and we will never never use the value from EDX.
 
+If you use the *DIV* instruction with a **divisor of 0**, the processor will generate a **"Divide Error" exception**, and the program will stop if it is not handled.
+
+Since division requires **EDX** to be set up properly, we should always **zero** it before performing DIV if we are working with unsigned values.
+
 ### Shift operations
 
 SHL (Shift left) and SHR (Shift right) are bitwise shift instructions.
@@ -117,17 +132,14 @@ SHL (Shift left) and SHR (Shift right) are bitwise shift instructions.
 - SHL:  Moves bits to the left, filling the rightmost bits with zeros. Each shift effectively **multiplies** the value by 2.
   - Example: `00001100` (`12` in decimal) shifted left by 1 becomes `00011000` (`24` in decimal).
 
-
 - SHR: Moves bits to the right, filling the leftmost bits with zeros. Each shift effectively **divides** the value by 2.
   - Example: `00001100` (`12` in decimal) shifted left by 1 becomes `00000110` (`6` in decimal).
 
-
 | **C Code**       | **ASM Code**    |
 |-------------     |---------------- |
 | `a = a << 1`     | `SHL eax, 1`    |
 | `b = b >> 2`     | `SHR ebx, 2`    |
 
-
 ### Conditional Statements
 
 #### CMP Instrunction
@@ -187,24 +199,68 @@ Here's a short description of each conditional jump:
 
 #### `for` loop
 
-| **C Code**                               | **ASM Code**          |
-|-------------                             |----------------       |
-| `for (a = 0; a < 10; a++) {`             | `MOV eax, 0`          |
-|                                          | `start_loop:`         |
-|                                          | `CMP eax, 10`         |
-|                                          | `JGE end_loop`        |
-| `// some code here`                      | `; some code here`    |
-|                                          | `ADD eax, 1`          |
-|                                          | `JMP start_loop`      |
-| `}`                                      | `end_loop:`           |
+| **C Code**                    | **ASM Code**          |
+|-------------                  |----------------       |
+| `for (a = 0; a < 10; a++) {`  | `MOV eax, 0`          |
+|                               | `start_loop:`         |
+|                               | `CMP eax, 10`         |
+|                               | `JGE end_loop`        |
+| `// some code here`           | `; some code here`    |
+|                               | `ADD eax, 1`          |
+|                               | `JMP start_loop`      |
+| `}`                           | `end_loop:`           |
 
 #### `while` loop
 
-| **C Code**                  | **ASM Code**                                                  |
-|-------------                |----------------                                               |
-| `while (b < 5) {`           | `start_loop:`                                                 |
-|                             | `CMP ebx, 5`                                                  |
-|                             | `JGE end_loop`                                                |
-| `// some code here`         | `; some code that makes b greater than or equal to 5`            |
-|                             | `JMP start_loop`                                              |
-| `}`                         | `end_loop:`                                                   |        
\ No newline at end of file
+| **C Code**          | **ASM Code**                                          |
+|-------------        |----------------                                       |
+| `while (b < 5) {`   | `start_loop:`                                         |
+|                     | `CMP ebx, 5`                                          |
+|                     | `JGE end_loop`                                        |
+| `// some code here` | `; some code that makes b greater than or equal to 5` |
+|                     | `JMP start_loop`                                      |
+| `}`                 | `end_loop:`                                           |        
+
+### Coding style
+
+Coding style can be run directly in the checker, by pressing `C`, or by using the
+`cs.sh` executable from `checker/cs`. The points are the folowing:
+
+- \>= 10 of `CHECK` => -5 points
+- \>= 5 of `WARNING` => -5 points
+- \>= 1 of `ERROR` => -10 points
+
+## Notes
+
+- The implementation can be done in any file, and the executable must be named 
+  `transpiler`, situated in the root of the folder, same as the initial makefile does
+- For sending the homework, you can use the `make pack` rule, which automatically creates
+  a zip file with the necesarry content already in it. Don't forget to change your name first
+
+## Checker
+
+> ! Atention, the checker doesn't run valgrind by default, but you must pass all the test
+with valgrind in order to get the score. To activate valgrind on your checker, press
+`v`, making sure there is a red border which will show that it is on.
+
+### Instalation steps
+
+You can use the `./install.sh` to install all the dependencies and the checker.
+If you find any errors along this process, try to follow the steps below:
+
+1. Download rustup using
+`curl https://sh.rustup.rs -sSf | sh -s -- -y`. If you get any errors
+after this step, add cargo to the PATH variable using `source "$HOME/.cargo/env"`.
+
+2. Run the following command to install the checker
+```bash
+$ cargo install hw_checker
+```
+
+After install, you can use the `hw_checker` command to run the checker.
+
+### Instructiuni checker
+
+For a list of commands and guides for the checker, please read the README from the
+`src/` directory. If you have any problems running the GUI, you can use the
+`hw_checker --legacy` command to run them in text only mode.

checker/input/08-transpiler.in

-c = c * 8;
-c = c * 1;
-c = c * 6;
+d = d * 8;
+c = c * c;
+c = c * b;

checker/input/09-transpiler.in

-b = b * 10;
 b = b * 4;
-b = b * 9;
-c = c * c;
-c = c * 6;
-c = c * a;
-c = c * 7;
+d = d * 7;
+c = c * 8;
+c = c * d;
 b = b * 0;
+b = b * 1;
+b = b * c;
+d = d * b;
+b = b * d;

checker/input/10-transpiler.in

-b = b / 0;
-b = b / 9;
-b = b / c;
-b = b / c;
+b = b / 8;
+b = b / 4;
+c = c / 0;
+c = c / 5;
+c = c / c;

checker/input/11-transpiler.in

-b = b / 8;
-b = b / 4;
-c = c / 0;
-c = c / 5;
-c = c / c;
 c = c / 2;
 c = c / 9;
 b = b / 8;
 b = b / 6;
 c = c / b;
+c = c / c;
+b = b / b;
+b = b / 5;
+b = b / 2;
+c = c / b;

checker/input/12-transpiler.in

-a = a >> 2;
-a = a << 14;
-d = d >> 14;
-b = b >> 1;
+d = d >> 20;
+a = a >> 24;
+b = b >> 4;
+b = b >> 7;
+d = d << 2;

checker/input/13-transpiler.in

-d = d >> 20;
-a = a >> 24;
-b = b >> 4;
-b = b >> 7;
-d = d << 2;
-c = c >> 25;
-c = c << 31;
-a = a >> 24;
+c = c >> 17;
+a = a >> 2;
+c = c >> 16;
+d = d >> 11;
+d = d >> 10;
+a = a << 0;
+b = b << 29;
+d = d << 8;
+c = c << 29;

checker/input/14-transpiler.in

-if (d >= 82)
-if (c >= 23)
-if (d == 20)
-if (a < 0)
+if (d >= 8) {
+	b = b * d;
+}
+if (d == 14) {
+	b = b | b;
+	d = d * b;
+	d = d << 1;
+	a = a - a;
+}
+if (d <= 67) {
+	b = b / 0;
+}
+if (a <= 96) {
+	d = d - c;
+}
+if (d == 82) {
+	a = a - 10;
+	b = b - 72;
+}

checker/input/15-transpiler.in

-if (b <= 93)
-if (d < 17)
-if (c < 80)
-if (d <= 93)
-if (a < 72)
-if (a > 75)
-if (d >= 73)
-if (d == 14)
+if (d <= 95) {
+	b = b - 72;
+	d = d * d;
+	b = b + c;
+	b = b ^ 65;
+	a = a + b;
+}
+if (d >= 87) {
+	d = d << 26;
+	b = b * 10;
+	d = d + d;
+	c = d;
+	b = b * c;
+}
+if (a == 82) {
+	a = a + 37;
+	c = c - b;
+	a = c;
+	d = d ^ 51;
+	b = b - 50;
+}
+if (b < 14) {
+	d = d + 13;
+	b = b >> 27;
+	a = a + 57;
+	a = a - 65;
+}
+if (a == 33) {
+	d = d + 61;
+	a = a + 86;
+	b = b / 10;
+}
+if (b >= 46) {
+	c = c / 0;
+	d = d >> 29;
+	c = c - 2;
+	a = a << 6;
+}
+if (d > 99) {
+	a = 40;
+	c = c * 4;
+	a = a - 82;
+	b = b >> 27;
+	a = a & 87;
+}
+if (a == 75) {
+	d = d >> 10;
+}
+if (c == 97) {
+	d = d * 2;
+}
+if (d > 50) {
+	a = a - 24;
+}

checker/input/16-transpiler.in

-while (b > 55)
-while (b > 69)
-while (a >= 2)
-while (b <= 97)
+while (b == 9) {
+	c = c - b;
+}
+while (c < 23) {
+	c = c | 11;
+	d = d & d;
+	c = c ^ 43;
+}
+while (d == 50) {
+	d = d ^ 69;
+	b = c;
+}
+while (a > 53) {
+	c = c / 3;
+	b = d;
+	c = c >> 20;
+	d = d + d;
+	a = 49;
+}

checker/input/17-transpiler.in

-while (b >= 3)
-while (d < 5)
-while (a <= 80)
-while (d >= 11)
-while (b <= 3)
-while (a <= 96)
-while (a <= 56)
-while (b == 58)
-while (c > 49)
-while (a <= 10)
+while (d == 85) {
+	c = c * 7;
+	a = a * 9;
+	b = b >> 27;
+	d = d - 5;
+}
+while (a >= 64) {
+	b = b + a;
+	c = c / c;
+	b = b >> 23;
+	a = a + d;
+	d = d;
+}
+while (d > 47) {
+	b = b & 57;
+}
+while (b <= 15) {
+	c = c / 8;
+	d = 77;
+	b = b | d;
+	d = d + 4;
+}
+while (c == 29) {
+	a = a;
+	a = a + 32;
+	b = 30;
+	b = b / 7;
+	d = d - 59;
+}
+while (b == 47) {
+	a = a >> 28;
+	c = c / 9;
+	b = b + 34;
+	b = b * a;
+}
+while (b == 25) {
+	c = c + 52;
+	b = b / 7;
+}
+while (a <= 18) {
+	c = b;
+	a = a - b;
+}
+while (c <= 70) {
+	a = 22;
+	c = c / 5;
+	c = c / c;
+	b = b >> 23;
+	b = b * 0;
+}

checker/input/18-transpiler.in

-while (b >= 72)
-while (d <= 95)
-while (d > 95)
-while (d >= 69)
+for (d = 0; d < 65; d = d + 1) {
+	c = c << 13;
+}
+for (a = 0; a <= 70; a = a + 1) {
+	d = d - 23;
+	c = c / 5;
+	b = b;
+	c = c | 80;
+	c = a;
+}
+for (d = 0; d < 14; d = d + 1) {
+	d = d >> 5;
+	d = d - a;
+}
+for (c = 0; c <= 23; c = c + 1) {
+	c = c / 5;
+	d = d & 93;
+}

checker/input/19-transpiler.in

-while (a <= 32)
-while (b < 99)
-while (c > 28)
-while (a == 65)
-while (c < 23)
-while (b >= 67)
-while (d >= 87)
-while (d < 52)
+for (d = 0; d <= 54; d = d + 1) {
+	a = a ^ 24;
+	d = d >> 10;
+	b = b * 6;
+}
+for (b = 0; b < 75; b = b + 1) {
+	c = c + 11;
+	b = b ^ 80;
+	d = d - c;
+	d = 69;
+}
+for (b = 0; b <= 86; b = b + 1) {
+	a = a * 2;
+}
+for (a = 0; a < 66; a = a + 1) {
+	b = b + 28;
+	a = 92;
+	b = b >> 21;
+}
+for (d = 0; d < 79; d = d + 1) {
+	b = b * b;
+	a = a - 25;
+	c = c ^ a;
+	d = d * 5;
+	c = c << 11;
+}
+for (d = 0; d < 47; d = d + 1) {
+	c = c * 10;
+}
+for (c = 0; c < 29; c = c + 1) {
+	d = d | a;
+	b = b + 93;
+	d = d << 30;
+	c = 9;
+}
+for (c = 0; c < 94; c = c + 1) {
+	c = c / 7;
+	c = c + 59;
+	c = c / c;
+	d = d * 8;
+}

checker/ref/00-transpiler.ref

-d = 77;
-b = 23;
-a = 96;
-a = 23;
-c = 58;
+MOV edx, 77
+MOV ebx, 23
+MOV eax, 96
+MOV eax, 23
+MOV ecx, 58

checker/ref/01-transpiler.ref

-a = c;
-d = d;
-d = 59;
-b = b;
-c = b;
-a = c;
-b = 76;
-b = 89;
+MOV eax, ecx
+MOV edx, edx
+MOV edx, 59
+MOV ebx, ebx
+MOV ecx, ebx
+MOV eax, ecx
+MOV ebx, 76
+MOV ebx, 89

checker/ref/02-transpiler.ref

-d = d & 42;
-b = b ^ 41;
-a = a ^ 39;
+AND edx, 42
+XOR ebx, 41
+XOR eax, 39

checker/ref/03-transpiler.ref

-c = c & 73;
-d = d & 45;
-a = a & 6;
-d = d & a;
-a = a | 19;
-b = b ^ a;
-a = a & 44;
-d = d ^ 89;
-d = d & 20;
-a = a & 41;
+AND ecx, 73
+AND edx, 45
+AND eax, 6
+AND edx, eax
+OR eax, 19
+XOR ebx, eax
+AND eax, 44
+XOR edx, 89
+AND edx, 20
+AND eax, 41