lonely-tiger/DataType.c

#include "DataType.h"

#define ARRAY_NAME 20
#define ARRAY_FACTOR 10

static char arrayName[ARRAY_NAME];

static const char* dtGetBaseName(DataType dt) {
    switch(dt) {
        case DT_INT: return "int";
        case DT_FLOAT: return "float";
        case DT_BOOL: return "bool";
        default: return "";
    }
}

static const char* dtGetArrayName(DataType dt) {
    int dimension = dt % ARRAY_FACTOR;
    DataType real = (dt / ARRAY_FACTOR) - 1;
    const char* name = dtGetBaseName(real);
    if(name[0] == '\0' || dimension <= 0 || dimension > dtMaxDimensions()) {
        return "unknown";
    }
    int index = 0;
    while(index < (ARRAY_NAME - 1) && name[index] != '\0') {
        arrayName[index] = name[index];
        index++;
    }
    while(index < (ARRAY_NAME - 1) && dimension > 0) {
        arrayName[index] = '*';
        index++;
        dimension--;
    }
    arrayName[index] = '\0';
    return arrayName;
}

const char* dtGetName(DataType dt) {
    const char* name = dtGetBaseName(dt);
    if(name[0] == '\0') {
        return dtGetArrayName(dt);
    }
    return name;
}

int dtGetSize(DataType dt) {
    switch(dt) {
        case DT_INT: return sizeof(int);
        case DT_FLOAT: return sizeof(float);
        case DT_BOOL: return sizeof(bool);
        default:
            if(dt >= STRUCT_OFFSET) {
                return 0;
            }
            return sizeof(int);
    }
}

DataType dtArray(DataType dt, int dimensions) {
    return (dt + 1) * ARRAY_FACTOR + dimensions;
}

DataType dtStruct(int id) {
    return STRUCT_OFFSET + id;
}

int dtMaxDimensions() {
    return ARRAY_FACTOR - 1;
}

bool dtIsArray(DataType dt) {
    return dt > ARRAY_FACTOR && dt < STRUCT_OFFSET;
}

bool dtIsStruct(DataType dt) {
    return dt >= STRUCT_OFFSET;
}