path: root/c/libdietc.l

%{
#include <assert.h>
#include <ctype.h>
#include <sys/stat.h>
#include "libdietc.h"

static void declare_pointer(char *);
static void declare_array(char *);
static void declare_function(char *);
static void predeclare_struct(char *);
static void predeclare_union(char *);
static void define_aggregate(char *);
static void declare_basic(char *);
static void declare_object(char *);
static void start_function(char *);
static void add_instruction(char *, enum INSTRUCTION_TYPE);
static void end_function();
%}
%%

^[#].*$ {}
"typedef Type_"[0-9]*" * Type_"[0-9]*" ;" { declare_pointer(yytext); }
"typedef Type_"[0-9]*" Type_"[0-9]*" [ "[^ ]*" ] ;" { declare_array(yytext); }
"typedef Type_"[0-9]*" Type_"[0-9]*" ( "[^)\n]*") ;" { declare_function(yytext); }
"typedef struct Struct_"[0-9]*" Type_"[0-9]*" ;" { predeclare_struct(yytext); }
"struct Struct_"[0-9]*" { "[^}\n]*"} ;"  { define_aggregate(yytext); }
"typedef union Union_"[0-9]*" Type_"[0-9]*" ;" { predeclare_union(yytext); }
"union Union_"[0-9]*" { "[^}\n]*"} ;"  { define_aggregate(yytext); }
"typedef "[^*\n\t(]*" ;" { declare_basic(yytext); }
"extern Type_"[0-9]*" "[^ \n]*" ;" { declare_object(yytext); }
"static Type_"[0-9]*" "[^ \n]*" ;" { declare_object(yytext); }
^[^=\n\t]*"= ".*$ { /* definition */ }
^[^{\n]*"{"$ { start_function(yytext); }
^\tType_[0-9]*" "[a-zA-Z0-9_]*" ;"$ {
        declare_object(yytext);
        add_instruction(yytext, INSTRUCTION_DECLARE);
    }
\t[*]" "[a-zA-Z_0-9]*" = "[a-zA-Z_0-9]*" ;"$ { add_instruction(yytext, INSTRUCTION_DEREF_ASSIGN); }
\t[a-zA-Z_0-9]*" = "[*]" "[a-zA-Z_0-9]*" ;"$ { add_instruction(yytext, INSTRUCTION_ASSIGN_DEREF); }
\t[a-zA-Z_0-9]*" = "[a-zA-Z_0-9]*" ;"$ { add_instruction(yytext, INSTRUCTION_COPY); }
\t[a-zA-Z_0-9]*" = ( Type_"[0-9]*" ) "[a-zA-Z_0-9]*" ;"$ { add_instruction(yytext, INSTRUCTION_CAST); }
\t[^\n]*$ { add_instruction(yytext, INSTRUCTION_OTHER); }
"}"$ { end_function(); }
\n { }
(.|[ \t]) { fprintf(stderr, "UNKNOWN: %s\n", yytext); }

%%
static struct program PROGRAM;
static struct function FUNCTION;
static struct instruction **NEXT_INSTRUCTION;

// skips to the next number in the string, reads past it, and then returns the
// read number. @ptr is left pointing to the char immediately after the number.
static int next_number(char **ptr) {
    int value = 0;
    while (**ptr && !isdigit(**ptr)) (*ptr)++;
    for (; isdigit(**ptr); (*ptr)++) value = (value * 10) + (**ptr - '0');
    return value;
}

static void add_type(struct type type) {
    if (PROGRAM.n_types <= type.id) {
        PROGRAM.n_types = type.id + 1;
        PROGRAM.id2type = realloc(PROGRAM.id2type,
                                  PROGRAM.n_types * sizeof(PROGRAM.id2type[0]));
    }
    PROGRAM.id2type[type.id] = malloc(sizeof(type));
    *(PROGRAM.id2type[type.id]) = type;
}

static struct type *typedup(struct type *type) {
    struct type *dup = malloc(sizeof(*dup));
    *dup = *type;
    return dup;
}

static void declare_pointer(char *line) {
    struct type type = {strdup(line), TYPE_POINTER, 0};
    type.base = PROGRAM.id2type[next_number(&line)];
    type.id = next_number(&line);
    add_type(type);
}

static void declare_array(char *line) {
    struct type type = {strdup(line), TYPE_ARRAY, 0};
    type.base = PROGRAM.id2type[next_number(&line)];
    type.id = next_number(&line);
    type.length = next_number(&line);
    if (*line == '\0') type.length = -1;
    add_type(type);
}

static void declare_function(char *line) {
    struct type type = {strdup(line), TYPE_FUNCTION, 0};
    type.return_type = PROGRAM.id2type[next_number(&line)];
    type.id = next_number(&line);
    if (strstr(line, "...")) type.is_variadic = 1;
    struct type **insert_arg = &(type.params);
    while (1) {
        int arg_id = next_number(&line);
        if (*line == '\0') break;
        *insert_arg = typedup(PROGRAM.id2type[arg_id]);
        insert_arg = &((*insert_arg)->next_param);
    }
    *insert_arg = 0;
    add_type(type);
}

static void predeclare_struct(char *line) {
    struct type type = {strdup(line), TYPE_STRUCT, next_number(&line), 0};
    add_type(type);
}

static void predeclare_union(char *line) {
    struct type type = {strdup(line), TYPE_UNION, next_number(&line), 0};
    add_type(type);
}

// struct Struct_[0-9]* [{] [^}]* [}] ;
// union Union_[0-9]* [{] [^}]* [}] ;
static void define_aggregate(char *line) {
    struct type *type = PROGRAM.id2type[next_number(&line)];
    line = strchr(line, 'T');
    struct type **insert_at = &(type->members);
    while (line && *line == 'T') {
        struct type *field_type = typedup(PROGRAM.id2type[next_number(&line)]);

        field_type->field_name = strdup(line + 1);
        *strchrnul(field_type->field_name, ' ') = '\0';

        *insert_at = field_type;
        insert_at = &(field_type->next_member);

        line = strchrnul(strchrnul(line, ';'), 'T');
    }
    *insert_at = 0;
}

static void declare_basic(char *line) {
    char *basic = strdup(line + strlen("typedef "));
    char *basic_end = basic;
    while (strncmp(basic_end, "Type_", strlen("Type_"))) basic_end++;
    basic_end--;
    // now basic_end is the space right before Type_
    *basic_end = '\0';
    char *type_name = line + (basic_end - basic);
    struct type type = {strdup(line), TYPE_BASIC, next_number(&type_name), 0};
    type.basic = basic;
    add_type(type);
}

char *libdietc_tokdup(char *str) {
    return strndup(str, strchrnul(str, ' ') - str);
}

static unsigned long hash(char *str) { // djb2
    unsigned long hash = 6997;
    for (; *str; str++) hash = hash * 33 ^ (*str);
    return hash;
}

// ... Type_# name ;
static void insert_object(struct object *object) {
    // MAYBE REHASH
    if (PROGRAM.n_objects >= PROGRAM.cap_objects / 2) {
        unsigned long old_cap = PROGRAM.cap_objects;
        struct object **old_objects = PROGRAM.objects;
        PROGRAM.cap_objects = 4 * (PROGRAM.n_objects + 1);
        PROGRAM.objects = calloc(PROGRAM.cap_objects, sizeof(void*));
        for (unsigned long i = 0; i < old_cap; i++)
            if (old_objects[i])
                insert_object(old_objects[i]);
        free(old_objects);
    }
    // INSERT
    PROGRAM.n_objects++;
    unsigned long h = hash(object->name) % PROGRAM.cap_objects;
    while (PROGRAM.objects[h])
        h = ((h + 1) % PROGRAM.cap_objects);
    PROGRAM.objects[h] = object;
}
static void declare_object(char *line) {
    struct object *object = calloc(1, sizeof(object));
    object->type = PROGRAM.id2type[next_number(&line)];
    object->name = libdietc_tokdup(line + 1);
    insert_object(object);
}

static void start_function(char *line) {
    FUNCTION = (struct function){0};
    FUNCTION.start_line = strdup(line);
    NEXT_INSTRUCTION = &(FUNCTION.instructions);
}

static void add_instruction(char *line, enum INSTRUCTION_TYPE kind) {
    *NEXT_INSTRUCTION = calloc(sizeof(**NEXT_INSTRUCTION), 1);
    (*NEXT_INSTRUCTION)->line = strdup(line);
    (*NEXT_INSTRUCTION)->kind = kind;
    (*NEXT_INSTRUCTION)->pprev = NEXT_INSTRUCTION;
    NEXT_INSTRUCTION = &((*NEXT_INSTRUCTION)->next);
}

static void end_function() {
    struct function **insert = &(PROGRAM.functions);
    while (*insert) insert = &((*insert)->next);
    *insert = calloc(1, sizeof(**insert));
    **insert = FUNCTION;
}

struct program libdietc_parse(char *filename) {
    PROGRAM = (struct program){0};

    FILE *f = fopen(filename, "r");
    assert(f);

    struct stat statinfo;
    stat(filename, &statinfo);
    int filesize = statinfo.st_size;

    // read whole file
    PROGRAM.original = malloc((statinfo.st_size + 1) * sizeof(char));
    fread(PROGRAM.original, statinfo.st_size, 1, f);
    PROGRAM.original[statinfo.st_size] = '\0';

    // identify end of the preamble
    char *end_preamble = strstr(PROGRAM.original, "{\n");
    if (!end_preamble) {
        PROGRAM.preamble = strdup(PROGRAM.original);
        PROGRAM.functions = NULL;
    } else {
        while (*end_preamble != '\n') end_preamble--;
        PROGRAM.preamble = PROGRAM.original;
        PROGRAM.original = strdup(PROGRAM.original);
        *(end_preamble + 1) = '\0';
    }

    // parse the file
    rewind(f);
    YY_BUFFER_STATE flex_buf = yy_create_buffer(f, YY_BUF_SIZE);
    yy_switch_to_buffer(flex_buf);
    yylex();

    return PROGRAM;
}

void libdietc_print(struct program program) {
    fputs(program.preamble, stdout);
    for (struct function *f = program.functions; f; f = f->next) {
        printf("%s\n", f->start_line);
        for (struct instruction *i = f->instructions; i; i = i->next)
            printf("%s\n", i->line);
        printf("}\n");
    }
}

char *libdietc_nth_token(char *string, int n) {
    while (isspace(*string)) string++;
    for (int i = 0; i < n; i++) {
        while (!isspace(*string)) string++;
        while (isspace(*string)) string++;
    }
    return string;
}

struct type *libdietc_object_type(struct program program, char *name) {
    char *name_tok = libdietc_tokdup(name);
    unsigned long h = hash(name_tok) % program.cap_objects;
    while (program.objects[h] && strcmp(program.objects[h]->name, name))
        h = (h + 1) % program.cap_objects;
    free(name_tok);
    return program.objects[h] ? program.objects[h]->type : 0;
}

struct type *libdietc_lhs_type(struct program program, struct instruction *instruction) {
    char *name = 0;
    if (instruction->line[1] == '*') {
        name = libdietc_tokdup(libdietc_nth_token(instruction->line, 1));
        return libdietc_object_type(program, name)->base;
    }
    name = libdietc_tokdup(libdietc_nth_token(instruction->line, 0));
    return libdietc_object_type(program, name);
}

struct instruction *libdietc_insert_before(struct instruction *i, char *line) {
    struct instruction *new = calloc(1, sizeof(*new));
    *(i->pprev) = new;
    new->pprev = i->pprev;
    new->line = line;
    new->next = i;
    i->pprev = &(new->next);
    return new;
}

struct instruction *libdietc_insert_after(struct instruction *i, char *line) {
    struct instruction *new = calloc(1, sizeof(*new));
    new->line = line;
    new->next = i->next;
    i->next->pprev = &(new->next);
    new->pprev = &(i->next);
    i->next = new;
    return new;
}