--there-will-be-huge-rebuild-improvment-update, if I have time :( contributions are accepted and appreciated.

CaptCC

A tiny Proof-of-Concept C compiler written purely in JavaScript.
It's been a while that I learned JS and it has worked for me in many different scenarios.
I actually learned JS while analyzing a piece of malware written in JS. Then I got really interested.
I was always curious if I can write a compiler; a tiny one.
The funny part was writing it in JS :D

Parts of this project is derived from James Kyle talk at EmberConf 2016 (https://www.youtube.com/watch?v=Tar4WgAfMr4).
I appreciate his effort to make this concept fairly easy to understand.
He made a Lisp Compiler converting Lisp syntax to JS.
I want to convert C to ASM.

The parts below are almost complete:

1. tokenizer.js
2. parser.js
3. traverser.js
4. processor.js

To be completed:

5. verifier.js
6. codeGenerator.js

State of the project:

What can be compiled:

• Function Definitions
• Integer Variable Assignments
• Char variable Assignments (i.e. char my_name[] = "Arash")
• Increments (var++)
• Additions and Subtraction
• Global Variables
• Return Statement
• Ifs Only (not nested, not if/elseif/else) Limited Condition support currently
• Function Calls with integer arguments

What can be parsed into the AST:

• Every legit character in C syntax
• Everything is grouped and parsed in a meaningful way
• Current groupings are "GlobalStatements" and "Functions".
• Inside GlobalStatements, there are Macros (Only #include for now :p), global varibales and structs.

What's missing from the parser:

typedef, define, ..., a lot!

Usage in browser console (remember to replace the new-lines with the actual \n while copy pasting this):

initGenerate(processor(transformer(parser(tokenizer("
//some comment here :D
int glob = 10;
int jack = 36;

void test_void(void){
    int a = 777;
    int b = a;
    b++;
    return;
}

int test_int_ret(int a, int b){
    a++;
    b++;
    char my_name[] = \"Arash\";
    return a;
}

int main(){
    char greet[] = \"hello\n\";
    int v = 1;
    int f = 8;

    v++;
    f++;

    int k = -4 - 3 + 5 - 7 - 8 + 2 - 32;

    int e = v;

    test(1,2);

    if(v == 2) {
        int y = 5;
        y++;
    }

    if(k == 35) {
        int p = 55 + 34;
    }

return 1;
}
"
)))))                   

Output:

.text
.globl _test_void

_test_void:
push %rbp
mov %rsp,%rbp
push $666
mov 0(%rsp),%rax
push %rax
incl (%rsp)
add $16,%rsp
pop %rbp
ret

.globl _test_int_ret

_test_int_ret:
push %rbp
mov %rsp,%rbp
push %rcx
push %rdx
incl 8(%rsp)
incl (%rsp)
mov 8(%rsp), %rax
add $16,%rsp
pop %rbp
ret

.globl main

main:
push %rbp
mov %rsp,%rbp
push $1
push $8
incl 8(%rsp)
incl (%rsp)
xor %rax,%rax
sub $4,%rax
sub $3,%rax
add $5,%rax
sub $7,%rax
sub $8,%rax
add $2,%rax
sub $32,%rax
push %rax
mov 16(%rsp),%rax
push %rax
cmp $2,24(%rsp)
jne _ifv2_after
push $5
incl (%rsp)
add $8,%rsp

_ifv2_after:
cmp $35,8(%rsp)
jne _ifk35_after
xor %rax,%rax
add $55,%rax
add $34,%rax
push %rax
add $8,%rsp

_ifk35_after: mov $1,%rax
add $32,%rsp
pop %rbp
ret

.data
.globl _glob
_glob:
.long 10

.globl _jack
_jack:
.long 36

To test the compiler code:

1. Copy the output into a file, let's say compiler_test.s

2. generate the binary using GCC

    gcc compiler_test.s -o compiler_test  
   

3. Run the binary