lonely-tiger/utils/Variables.c

#include <stdlib.h>
#include <string.h>

#include "utils/Variables.h"

void vInit(Variables* v) {
    v->capacity = 16;
    vReset(v);
    v->data = malloc(sizeof(Variable) * v->capacity);
}

void vDelete(Variables* v) {
    free(v->data);
}

static Variable* vSearchUntil(Variables* v, const char* s, int index) {
    for(int i = v->entries - 1; i >= index; i--) {
        if(strcmp(s, v->data[i].name) == 0) {
            return v->data + i;
        }
    }
    return NULL;
}

Variable* vSearch(Variables* v, const char* s) {
    return vSearchUntil(v, s, 0);
}

Variable* vSearchScope(Variables* v, const char* s) {
    return vSearchUntil(v, s, v->scope);
}

bool vSearchStruct(Variable* v, Structs* sts, Struct* st, const char* s) {
    for(int i = 0; i < st->amount; i++) {
        if(strcmp(st->vars[i].name, s) == 0) {
            v->name = s;
            v->type = st->vars[i].type;
            return false;
        }
        v->address += dtGetSize(st->vars[i].type, sts);
    }
    return true;
}

Variable* vAdd(Variables* v, const char* s, DataType type, Structs* sts) {
    if(v->entries >= v->capacity) {
        v->capacity *= 2;
        v->data = realloc(v->data, sizeof(Variable) * v->capacity);
    }
    int index = v->entries++;
    v->data[index] = (Variable){s, type, v->address};
    v->address += dtGetSize(type, sts);
    if(v->address > v->maxAddress) {
        v->maxAddress = v->address;
    }
    return v->data + index;
}

void vReset(Variables* v) {
    v->entries = 0;
    v->address = 0;
    v->scope = 0;
    v->maxAddress = 0;
}

void vEnterScope(Variables* v, Scope* s) {
    s->address = v->address;
    s->entries = v->entries;
    s->scope = v->scope;
    v->scope = v->entries;
}

void vLeaveScope(Variables* v, Scope* s) {
    v->address = s->address;
    v->entries = s->entries;
    v->scope = s->scope;
}