# MinimalCC
Minimal C subset compiler

Currently compiles to MIPS assembly which runs on MARS and SPIM.

Build using `make`, which will produce an executable named `mcc`.

## Quickstart (Execution using SPIM)
There is a folder called `tests`, which allows you to test the assembler. 

We will build and execute a program which prints all of the primes less than 5000. First compile the file `tests/primes.cc` using the command `./mcc tests/primes.cc -o tests/primes.s`. This creates an assembly file named `primes.s` in the `tests` folder. Next, we need to add it's dependencies so that SPIM can execute the program. In `test` there is a file named `main.s` which serves as an entry point into the C program. Also, there are files `prints.s` and `printd.s` which are functions to print strings and integers respectively. We can combine these files into one file named `run.s` using the command `cat tests/primes.s tests/main.s tests/prints.s tests/printd.s > run.s`. Finally, if you are using SPIM, you can execute the program by running `spim -file run.s`. After a few seconds of calculation, it should print all of the prime numbers less than 5000! You can change the program in `tests/primes.cc` how you like to change the functionality. 

## Features
### List of Binary Operations
- `+` Addition
- `-` Subtraction
- `*` Multiplication
- `/` Division
- `=` Assign
- `<` Less than
- `>` Greater than
- `<=` Less than or equal
- `>=` Greater than or equal
- `==` Equals
- `!=` Not equals
- `&` Bitwise AND
- `|` Bitwise OR
- `%` Modulo
- `&&` Logical AND
- `||` Logical OR
- `<<` Shift left
- `>>` Shift right (arithmetic)

### List of Unary Operations
- `*` Dereference
- `&` Reference
- `!` Logical not
- `~` Bitwise not
- `-` Negation

### List of Supported Datatypes
- The following primitive datatypes:
  - `int` which is 4 bytes big
  - `char` which is 1 byte big
  - `void`
- Pointers to another type
- Functions and function pointers
- Local and global lists

### List of Supported Keywords
- `while`
- `if`
- `else`
- `for`
- `return`
- `break`
- `continue`

Note that due to the efficiency considerations, datatypes take up constant storage inside the compiler, which means that datatypes that are complicated enough can "overflow" the type system in the compiler. Currently there is no detection for this, but this is another thing I plan to add. It is also possible to modify the compiler to be able to parse even more complex datatypes, but it becomes a trade-off between flexibility and efficiency. Currently, almost any datatype a sane programmer would use will not overflow the type system for the compiler.