#include "regexp.h"

bool reg_issimple(regexp *expr) {
  // cas de base epression vide
  if (expr == NULL) {
    return true;
  }

  // test si l'expression contient une intersection ou un complement
  if (expr->op == INTER || expr->op == COMPLEMENT) {
    return false;
  }

  // on teste les sous expressions
  return reg_issimple(expr->left) && reg_issimple(expr->right);
}

void reg_free(regexp *expr) {
  if (expr == NULL) {
    return;
  }
  // Libérer récursivement les sous-expressions gauche et droite
  reg_free(expr->left);
  reg_free(expr->right);
  free(expr);
}

regexp *reg_copy(regexp *expr) {
  // cas de base
  if (expr == NULL) {
    return NULL;
  }

  regexp *new_expr = malloc(sizeof(regexp));

  // on complète les champs
  new_expr->op = expr->op;
  new_expr->letter = expr->letter;
  new_expr->left = reg_copy(expr->left);
  new_expr->right = reg_copy(expr->right);

  return new_expr;
}

regexp *reg_empty(void) {
  regexp *void_expr = malloc(sizeof(regexp));
  void_expr->op = EMPTY;
  void_expr->left = NULL;
  void_expr->right = NULL;
  void_expr->letter = '\0';
  return void_expr;
}

regexp *reg_epsilon(void) {
  regexp *epsilon = malloc(sizeof(regexp));
  epsilon->op = EPSILON;
  epsilon->left = NULL;
  epsilon->right = NULL;
  epsilon->letter = '\0';
  return epsilon;
}

regexp *reg_letter(char c) {
  regexp *lettre = malloc(sizeof(regexp));
  lettre->op = CHAR;
  lettre->left = NULL;
  lettre->right = NULL;
  // la lettre de l'expression
  lettre->letter = c;
  return lettre;
}

regexp *reg_union(regexp *expr_left, regexp *expr_right) {
  regexp *uni = malloc(sizeof(regexp));
  uni->op = UNION;
  uni->left = expr_left;
  uni->right = expr_right;
  uni->letter = '\0';
  return uni;
}

regexp *reg_inter(regexp *expr_left, regexp *expr_right) {
  regexp *inter = malloc(sizeof(regexp));
  inter->op = INTER;
  inter->left = expr_left;
  inter->right = expr_right;
  inter->letter = '\0';
  return inter;
}

regexp *reg_concat(regexp *expr_left, regexp *expr_right) {
  regexp *concat = malloc(sizeof(regexp));
  concat->op = CONCAT;
  concat->left = expr_left;
  concat->right = expr_right;
  concat->letter = '\0';
  return concat;
}

regexp *reg_star(regexp *expr) {
  regexp *star = malloc(sizeof(regexp));
  star->op = STAR;
  star->left = expr;
  star->right = NULL;
  star->letter = '\0';
  return star;
}

regexp *reg_complement(regexp *expr) {
  regexp *compl = malloc(sizeof(regexp));
  compl->op = COMPLEMENT;
  compl->left = expr;
  compl->right = NULL;
  compl->letter = '\0';
  return compl;
}