semtable.c

Go to the documentation of this file.

#include "semtable.h"
#include "def.h"

SemTable *_sem_new() {
    SemTable * sem= malloc(sizeof(SemTable));
    memset(sem,0,sizeof(SemTable));
}

int _sem_new_context(SemTable *sem,T *definitions) {

    if (sem->contexts >= MAX_CONTEXTS-1) raise_error("no more room in semtable");
    int idx = sem->contexts++;
    //    sem->stores[idx].table = NULL;
    sem->stores[idx].definitions = definitions;
    return idx;
}

void _sem_free(SemTable *sem) {
    free(sem);
}

ContextStore *__sem_context(SemTable *sem,Context c) {
    return &sem->stores[c];
}

void _sem_free_context(SemTable *sem,Context c) {
    ContextStore *ctx = __sem_context(sem,c);
    // definition tree belong to the receptors that allocated them so
    // we never free them.
    ctx->definitions = NULL;
    //if (ctx->table) lableTableFree(ctx->table);

    if ((c+1) == sem->contexts)
        sem->contexts--;
}

char G_ctx_buf[20];

char *_sem_ctx2s(SemTable *sem,Context c) {
    switch(c) {
    case SYS_CONTEXT:return "SYS_CONTEXT";
    case COMPOSITORY_CONTEXT:return "COMPOSITORY_CONTEXT";
    case DEV_COMPOSITORY_CONTEXT:return "DEV_COMPOSITORY_CONTEXT";
    case TEST_CONTEXT:return "TEST_CONTEXT";
    default:
        sprintf(G_ctx_buf,"%d",c);
        return G_ctx_buf;
    }
}

// get the definitions for the semantic type of the semid
T *__sem_get_defs(SemTable *sem,SemanticType semtype,Context c) {
    ContextStore *ctx = __sem_context(sem,c);
    if (!ctx->definitions) raise_error("no definitions in context %s",_sem_ctx2s(sem,c));
    T *defs = _t_child(ctx->definitions,semtype);
    if (!defs) raise_error("no defs for semtype %d in context %s",semtype,_sem_ctx2s(sem,c));
    return defs;
}

T *__sem_get_def(SemTable *sem,SemanticType semtype,Context c,SemanticAddr i) {
    T *defs = __sem_get_defs(sem,semtype,c);
    return _t_child(defs,i);
}

char *_sem_get_name(SemTable *sem,SemanticID s) {
    if (s.id == 0) {
        if (s.context == SYS_CONTEXT) {
            switch (s.semtype) {
            case SEM_TYPE_STRUCTURE: return "NULL_STRUCTURE";
            case SEM_TYPE_SYMBOL: return "NULL_SYMBOL";
            case SEM_TYPE_PROCESS: return "NULL_PROCESS";
            case SEM_TYPE_RECEPTOR: return "SYS_RECEPTOR";
            default: raise_error("bad semtype");
            }
        }
        else {
            raise_error("unexpected semantic NULL id!");
        }
    }
    T *def = _sem_get_def(sem,s);
    char *n = NULL;
    if (def) {
        int path[] ={DefLabelIdx,1,TREE_PATH_TERMINATOR};
        T *t = _t_get(def,path);
        if (!t) raise_error("missing label!");
        n = (char *)_t_surface(t);
    }
    return n;
}

T * _sem_get_label(SemTable *sem,SemanticID s,Symbol label_type) {
    if (s.id == 0) {
        raise_error("semantic NULL have no defs!");
    }
    T *def = _sem_get_def(sem,s);
    T *label = NULL;
    if (def) {
        T *labels = _t_child(def,DefLabelIdx);
        label = _t_find(labels,label_type);
        if (!label) label = _t_child(labels,1);
    }
    return label;
}
void _sem_add_label(SemTable *sem,SemanticID s,Symbol label_type,char *label) {
    T *def = _sem_get_def(sem,s);
    T *labels  = _t_child(def,DefLabelIdx);
    _t_new_str(labels,label_type,label);
}

Structure _sem_get_symbol_structure(SemTable *sem,Symbol s){
    if (!is_symbol(s)) raise_error("Bad symbol: semantic type not SEM_TYPE_SYMBOL");
    return __d_get_symbol_structure(_sem_get_defs(sem,s),s);
}

// @todo, convert this to hash table label table!!
bool __sem_get_by_label(SemTable *sem,char *label,SemanticID *sid,Context c) {
    ContextStore *ctx = __sem_context(sem,c);
    T *d = ctx->definitions;
    if (!d) raise_error("no definitions in context %s",_sem_ctx2s(sem,c));
    int i,j;
    for(i=1;i<=_t_children(d);i++) {
        T *defs = _t_child(d,i);
        for(j=1;j<=_t_children(defs);j++) {
            T *def = _t_child(defs,j);
            if (strcmp(label,(char *)_t_surface(_t_child(_t_child(def,DefLabelIdx),1)))==0) {
                sid->semtype = i;
                sid->id = j;
                sid->context = c;
                return true;
            }
        }
    }
    return false;
}

bool _sem_get_by_label(SemTable *sem,char *label,SemanticID *sid) {
    int i;
    if (!strcmp(label,"NULL_SYMBOL")) {*sid = NULL_SYMBOL; return true;}
    for(i=0;i<sem->contexts;i++)
        if (__sem_get_by_label(sem,label,sid,i)) return true;
    return false;
}