.gitignore

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

Dockerfile

-FROM ghcr.io/open-education-hub/vmcheker-next-base-image/base-container:latest
-
-ENV DEBIAN_FRONTEND noninteractive
-
-RUN apt-get update
-
-RUN apt-get install -yqq gcc-multilib gdb curl && \
-    apt-get install -y build-essential valgrind
-
-RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
-
-ENV PATH="/root/.cargo/bin:${PATH}"
+FROM gitlab.cs.pub.ro:5050/iocla/tema-1-2024
 
 RUN cargo install hw_checker
 
-
 COPY ./checker ${CHECKER_DATA_DIRECTORY}
+COPY ./data.json ${CHECKER_DATA_DIRECTORY}

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 functional
+	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/checker.sh

@@ -6,9 +6,7 @@ test_all()
     make clean
     ulimit -n 1024
     cd ..
-    echo '<VMCK_NEXT_BEGIN>'
     hw_checker --legacy
-    echo '<VMCK_NEXT_END>'
 }
 
 test_all

checker/input/00-transpiler.in

-b = 4
-a = b
\ No newline at end of file
+d = 77;
+b = 23;
+a = 96;
+a = 23;
+c = 58;

checker/input/01-transpiler.in

+a = c;
+d = d;
+d = 59;
+b = b;
+c = b;
+a = c;
+b = 76;
+b = 89;

checker/input/02-transpiler.in

+d = d & 42;
+b = b ^ 41;
+a = a ^ 39;

checker/input/03-transpiler.in

+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;

checker/input/04-transpiler.in

+a = a + d;
+c = c + 26;
+b = b + b;
+b = b + 63;

checker/input/05-transpiler.in

+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;

checker/input/06-transpiler.in

+a = a - a;
+d = d - b;
+c = c - b;
+a = a - 55;
+b = b - 16;

checker/input/07-transpiler.in

+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;

checker/input/08-transpiler.in

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

checker/input/09-transpiler.in

+b = b * 4;
+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 / 8;
+b = b / 4;
+c = c / 0;
+c = c / 5;
+c = c / c;

checker/input/11-transpiler.in

+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

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