117 lines
2.5 KiB
C
117 lines
2.5 KiB
C
#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;
|
|
}
|