#include "regexp.h"

bool reg_issimple(regexp *expression) {
    if (expression == NULL) return true;
    if (expression->op == INTER || expression->op == COMPLEMENT) return false;
    return reg_issimple(expression->left) && reg_issimple(expression->right);
}

void reg_free(regexp *expression) {
    if (expression == NULL) return;
    reg_free(expression->left);
    reg_free(expression->right);
    free(expression);
    return;
}

regexp *reg_copy(regexp *expression) {
    if (expression == NULL) return NULL;
    // on alloue de la mémoire pour la copie
    regexp *copy = malloc(sizeof(regexp));
    // on copie les champs de l'expression
    copy->op = expression->op;
    copy->letter = expression->letter;
    // on copie les sous-expressions de manière récursive
    copy->left = reg_copy(expression->left);
    copy->right = reg_copy(expression->right);
    // on retourne la copie effectuée
    return copy;
}

regexp *reg_empty(void) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_empty : malloc failed");
    } else {
        ptr->op = EMPTY;
        ptr->letter = '\0';
        ptr->left = NULL;
        ptr->right = NULL;
    }
    return ptr;
}

regexp *reg_epsilon(void) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_epsilon : malloc failed");
    } else {
        ptr->op = EPSILON;
        ptr->letter = '\0';
        ptr->left = NULL;
        ptr->right = NULL;
    }
    return ptr;
}

regexp *reg_letter(char c) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_lettre : malloc failed");
    } else {
        ptr->op = CHAR;
        ptr->letter = c;
        ptr->left = NULL;
        ptr->right = NULL;
    }
    return ptr;
}

regexp *reg_union(regexp *ptr_left, regexp *ptr_right) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_union : malloc failed");
    } else {
        ptr->op = UNION;
        ptr->letter = '\0';
        ptr->left = ptr_left;
        ptr->right = ptr_right;
    }
    return ptr;
}

regexp *reg_inter(regexp *ptr_left, regexp *ptr_right) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_inter : malloc failed");
    } else {
        ptr->op = INTER;
        ptr->letter = '\0';
        ptr->left = ptr_left;
        ptr->right = ptr_right;
    }
    return ptr;
}

regexp *reg_concat(regexp *ptr_left, regexp *ptr_right) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_concat : malloc failed");
    } else {
        ptr->op = CONCAT;
        ptr->letter = '\0';
        ptr->left = ptr_left;
        ptr->right = ptr_right;
    }
    return ptr;
}

regexp *reg_star(regexp *expression) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_star : malloc failed");
    } else {
        ptr->op = STAR;
        ptr->letter = '\0';
        ptr->left = expression;
        ptr->right = NULL;
    }
    return ptr;
}

regexp *reg_complement(regexp *expression) {
    regexp *ptr = malloc(sizeof(regexp));
    if (ptr == NULL) {
        ERROR("reg_complement : malloc failed");
    } else {
        ptr->op = COMPLEMENT;
        ptr->letter = '\0';
        ptr->left = expression;
        ptr->right = NULL;
    }
    return ptr;
}