.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

 d = d * 8;
 c = c * c;
-c = c * a;
+c = c * b;

checker/input/09-transpiler.in

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

checker/input/17-transpiler.in

 while (d == 85) {
 	c = c * 7;
-	a = a * 9
+	a = a * 9;
 	b = b >> 27;
 	d = d - 5;
 }

checker/input/19-transpiler.in

@@ -10,7 +10,7 @@ for (b = 0; b < 75; b = b + 1) {
 	d = 69;
 }
 for (b = 0; b <= 86; b = b + 1) {
-	a = a * 2
+	a = a * 2;
 }
 for (a = 0; a < 66; a = a + 1) {
 	b = b + 28;

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

checker/ref/04-transpiler.ref

-a = a + d;
-c = c + 26;
-b = b + b;
-b = b + 63;
+ADD eax, edx
+ADD ecx, 26
+ADD ebx, ebx
+ADD ebx, 63

checker/ref/05-transpiler.ref

-c = c + 65;
-b = b + d;
-b = b + 20;
-d = d + a;
-b = b + d;
-d = d + 23;
-c = c + b;
-c = c + 52;
-a = a + 83;
+ADD ecx, 65
+ADD ebx, edx
+ADD ebx, 20
+ADD edx, eax
+ADD ebx, edx
+ADD edx, 23
+ADD ecx, ebx
+ADD ecx, 52
+ADD eax, 83

checker/ref/06-transpiler.ref

-a = a - a;
-d = d - b;
-c = c - b;
-a = a - 55;
-b = b - 16;
+SUB eax, eax
+SUB edx, ebx
+SUB ecx, ebx
+SUB eax, 55
+SUB ebx, 16

checker/ref/07-transpiler.ref

-b = b - 55;
-b = b - 22;
-b = b - 70;
-b = b - 90;
-b = b - 50;
-d = d - 82;
-a = a - 67;
-d = d - 83;
-b = b - 28;
-b = b - b;
+SUB ebx, 55
+SUB ebx, 22
+SUB ebx, 70
+SUB ebx, 90
+SUB ebx, 50
+SUB edx, 82
+SUB eax, 67
+SUB edx, 83
+SUB ebx, 28
+SUB ebx, ebx

checker/ref/08-transpiler.ref

-c = c * 8;
-c = c * 1;
-c = c * 6;
+MOV eax, edx
+MUL 8
+MOV edx, eax
+MOV eax, ecx
+MUL ecx
+MOV ecx, eax
+MOV eax, ecx
+MUL ebx
+MOV ecx, eax

checker/ref/09-transpiler.ref

-b = b * 10;
-b = b * 4;
-b = b * 9;
-c = c * c;
-c = c * 6;
-c = c * a;
-c = c * 7;
-b = b * 0;
+MOV eax, ebx
+MUL 4
+MOV ebx, eax
+MOV eax, edx
+MUL 7
+MOV edx, eax
+MOV eax, ecx
+MUL 8
+MOV ecx, eax
+MOV eax, ecx
+MUL edx
+MOV ecx, eax
+MOV eax, ebx
+MUL 0
+MOV ebx, eax
+MOV eax, ebx
+MUL 1
+MOV ebx, eax
+MOV eax, ebx
+MUL ecx
+MOV ebx, eax
+MOV eax, edx
+MUL ebx
+MOV edx, eax
+MOV eax, ebx
+MUL edx
+MOV ebx, eax

checker/ref/10-transpiler.ref

-d = d / d;
-b = b / c;
-d = d / b;
-c = c / a;
+MOV eax, ebx
+DIV 8
+MOV ebx, eax
+MOV eax, ebx
+DIV 4
+MOV ebx, eax
+Error
+MOV eax, ecx
+DIV 5
+MOV ecx, eax
+MOV eax, ecx
+DIV ecx
+MOV ecx, eax

checker/ref/11-transpiler.ref

-d = d / b;
-d = d / c;
-c = c / 7;
-d = d / d;
-c = c / 5;
-b = b / 5;
-c = c / c;
-d = d / 8;
-d = d / 4;
+MOV eax, ecx
+DIV 2
+MOV ecx, eax
+MOV eax, ecx
+DIV 9
+MOV ecx, eax
+MOV eax, ebx
+DIV 8
+MOV ebx, eax
+MOV eax, ebx
+DIV 6
+MOV ebx, eax
+MOV eax, ecx
+DIV ebx
+MOV ecx, eax
+MOV eax, ecx
+DIV ecx
+MOV ecx, eax
+MOV eax, ebx
+DIV ebx
+MOV ebx, eax
+MOV eax, ebx
+DIV 5
+MOV ebx, eax
+MOV eax, ebx
+DIV 2
+MOV ebx, eax
+MOV eax, ecx
+DIV ebx
+MOV ecx, eax