Initial commit

Author: edwardatki

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,55 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+.vscode
+*.bin

makefile

@@ -0,0 +1,11 @@
+.DEFAULT_GOAL := main.bin
+
+run: main.bin
+	./main.bin
+
+main.bin: src/*
+	gcc src/*.c -o main.bin
+
+clean:
+	mkdir -p build
+	rm -f build/*

sample.s

@@ -0,0 +1,20 @@
+uint8 test1 = 123;
+uint8 test2 = 0xea;
+uint8 test3 = 0b01010101;
+uint8 test4 = 'a';
+uint8* pointer1 = &test1;
+uint8 test5 = *pointer1;
+
+uint8 divide (uint8 value, uint8 divisor) {
+    uint8 i = 0;
+    while (value > 0) {
+        value = value - divisor;
+        i = i + 1;
+    }
+    return i;
+}
+
+uint8_t main () {
+    divide(7, 2);
+    return 0;
+}

src/generator.c

@@ -0,0 +1,98 @@
+#include "generator.h"
+
+static int visit(Node*, int);
+
+static char intermediateCode [1024];
+static char* codePointer = intermediateCode;
+
+static int registerUse[8] = {0};
+static char* registerNames[] = {"rdi", "rsi", "rdx", "rcx", "r8", "r9"};
+
+static int allocReg() {
+    for (int i = 0; i < sizeof(registerUse)/sizeof(int); i++) {
+        if (registerUse[i] == 0) {
+            registerUse[i] = 1;
+            return i;
+        }
+    }
+}
+
+static void freeReg(int i) {
+    registerUse[i] = 0;
+}
+
+static void visitAll(NodeListEntry* listRoot, int depth) {
+    if (listRoot == NULL) return;
+    NodeListEntry* curEntry = listRoot;
+    while (curEntry->next != NULL) {
+        curEntry = curEntry->next;
+        visit(curEntry->node, depth);
+    }
+}
+
+static void printIndent(int depth) {
+    for (int i = 0; i < depth; i++) {
+        printf(" ");
+    }
+}
+
+static int visit(Node* node, int depth) {
+    printIndent(depth);
+    switch (node->type) {
+        case N_VAR_DECL:
+            // TODO decide symbol location in memory
+            printf("Variable declaration: %s %s\n", node->VarDecl.symbol->type->name, node->VarDecl.symbol->token->value);
+            break;
+        case N_FUNC_DECL:
+            printf("Function declaration: %s %s\n", node->FunctionDecl.returnType->name, node->token->value);
+            codePointer += sprintf(codePointer, "LABEL %s\n", node->token->value);
+            visitAll(node->FunctionDecl.formalParameters, depth+1);
+            visit(node->FunctionDecl.block, depth+1);
+            break;
+        case N_BLOCK:
+            printf("Block\n");
+            visitAll(node->Block.variableDeclarations, depth+1);
+            visitAll(node->Block.statements, depth+1);
+            break;
+        case N_NUMBER:
+            printf("Number: %s\n", node->token->value);
+            int regN = allocReg();
+            codePointer += sprintf(codePointer, "COPY %s -> R%d %s\n", node->token->value, regN);
+            return regN;
+        case N_VARIABLE:
+            printf("Variable: %s\n", node->token->value);
+            int regV = allocReg();
+            // TODO use symbol location instead of token value
+            codePointer += sprintf(codePointer, "COPY %s -> R%d\n", node->token->value, regV);
+            return regV;
+        case N_ASSIGNMENT:
+            printf("Assignment: %s\n", node->token->value);
+            int regA = visit(node->Assignment.expr, depth+1);
+            codePointer += sprintf(codePointer, "COPY R%d -> %s\n", regA, node->token->value);
+            break;
+        case N_BINOP:
+            printf("BinOp: %s\n", node->token->value);
+            int regL = visit(node->BinOp.left, depth+1);
+            int regR = visit(node->BinOp.right, depth+1);
+            int regRes = allocReg();
+            codePointer += sprintf(codePointer, "BINOP R%d %s R%d -> R%d\n", regL, node->token->value, regR, regRes);
+            freeReg(regL);
+            freeReg(regR);
+            return regRes;
+        case N_RETURN:
+            printf("Return\n");
+            int reg = visit(node->Return.expr, depth+1);
+            codePointer += sprintf(codePointer, "RET R%d\n", reg);
+            return reg;
+        default:
+            printf("Unknown node type!\n");
+            break;
+    }
+
+    return 0;
+}
+
+char* generate(Node* rootNode) {
+    visit(rootNode, 0);
+    return intermediateCode;
+}

src/generator.h

@@ -0,0 +1,11 @@
+#ifndef _GENERATOR_H
+#define _GENERATOR_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "lexer.h"
+#include "parser.h"
+
+char* generate(Node*);
+
+#endif

src/lexer.c

@@ -0,0 +1,89 @@
+#include "lexer.h"
+
+static Token* curToken;
+
+static Token* newToken(enum TokenType type) {
+    Token* token = calloc(1, sizeof(Token));
+    token->type = type;
+    return token;
+}
+
+static void addToken(enum TokenType type, char* value) {
+    Token* token = newToken(T_END);
+    curToken->next = token;
+    curToken->type = type;
+    curToken->value = value;
+    curToken = token;
+}
+
+static char next(FILE* fp) {
+    char c = getc(fp);
+    return c;
+}
+
+static char peek(FILE* fp) {
+    char c = getc(fp);
+    ungetc(c, fp);
+    return c;
+}
+
+static int isWhitespace(char c) {
+    if (c == ' ') return 1;
+    if (c == '\t') return 1;
+    return 0;
+}
+
+static void checkNumeric(FILE* fp, char c) {
+    char* value = calloc(32, sizeof(char));
+    int i = 0;
+    while(1) {
+        value[i++] = c;
+        if (!isdigit(peek(fp))) break;
+        c = tolower(fgetc(fp));
+    }
+
+    addToken(T_NUMBER, value);
+}
+
+static void checkKeyword(FILE* fp, char c) {
+    char* value = calloc(32, sizeof(char));
+    int i = 0;
+    while(1) {
+        value[i++] = c;
+        if (!isalnum(peek(fp))) break;
+        c = tolower(fgetc(fp));
+    }
+
+    if (strcmp(value, "return") == 0) addToken(T_RETURN, value);
+    else if (strcmp(value, "uint8") == 0) addToken(T_TYPE, value);
+    else addToken(T_ID, value);
+}
+
+Token* lex(FILE* fp) {
+    Token* firstToken = newToken(T_END);
+    curToken = firstToken;
+
+    while (1) {
+        char c = next(fp);
+        
+        if (c == EOF) {addToken(T_END, NULL); break;}
+        if (isWhitespace(c)) continue;
+
+        if (c == '(') {addToken(T_LPAREN, "{"); continue;}
+        if (c == ')') {addToken(T_RPAREN, "}"); continue;}
+        if (c == '{') {addToken(T_LBRACE, "{"); continue;}
+        if (c == '}') {addToken(T_RBRACE, "}"); continue;}
+        if (c == ',') {addToken(T_COMMA, ","); continue;}
+        if (c == '+') {addToken(T_PLUS, "+"); continue;}
+        if (c == '-') {addToken(T_MINUS, "-"); continue;}
+        if (c == '*') {addToken(T_MUL, "*"); continue;}
+        if (c == '/') {addToken(T_DIV, "/"); continue;}
+        if (c == '=') {addToken(T_ASSIGN, "="); continue;}
+        if (c == ';') {addToken(T_SEMICOLON, ";"); continue;}
+
+        if (isdigit(c)) {checkNumeric(fp, c); continue;}
+        if (isalpha(c)) {checkKeyword(fp, c); continue;}
+    }
+
+    return firstToken;
+}

src/lexer.h

@@ -0,0 +1,20 @@
+#ifndef _LEXER_H
+#define _LEXER_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+enum TokenType {T_END=0, T_LPAREN, T_RPAREN, T_LBRACE, T_RBRACE, T_COMMA, T_PLUS, T_MINUS, T_MUL, T_DIV, T_ASSIGN, T_NUMBER, T_RETURN, T_ID, T_TYPE, T_SEMICOLON};
+
+typedef struct Token Token;
+struct Token {
+    enum TokenType type;
+    char *value;
+    Token *next;
+};
+
+Token* lex(FILE*);
+
+#endif

src/main.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include "lexer.h"
+#include "parser.h"
+#include "generator.h"
+
+int main() {
+    FILE *fp;
+    fp = fopen("test.s", "r");
+    
+    Token* firstToken = lex(fp);
+
+    Node* rootNode = parse(firstToken);
+
+    char* result = generate(rootNode);
+    printf("%s", result);
+
+    return 0;
+}