//Integrntes Alejandro Ortiz, Cindy Barcenas //Transformation AFN en AFD // #include <stdio.h> #include <stdlib.

h> #define EPSILON -1 #define NOETAT -1 // A F N typedef struct ptr_list* ptr_list_t; struct ptr_list { int info; ptr_list_t suiv; }; typedef struct ptr_trans* ptr_trans_t; struct ptr_trans { int e, s; ptr_list_t vers_e; ptr_trans_t suiv; }; typedef struct { ptr_list_t ptr_list_t ptr_trans_t }afn_t; // A F D typedef struct ptr_detat* ptr_detat_t; struct ptr_detat { int e; ptr_list_t letat; ptr_detat_t suiv; }; typedef struct ptr_dtrans* ptr_dtrans_t; struct ptr_dtrans { int de, s, fe; ptr_dtrans_t suiv; }; typedef struct { ptr_detat_t ldetat; ptr_list_t lsymb; ptr_dtrans_t ltrans; }afd_t; // P R O T O T Y P E

letat; lsymb; ltrans;

afn_t* void afd_t* void void

saisie_afn(); affiche_afd(afd_t*); afn2afd(afn_t*); free_afn(afn_t*); free_afd(afd_t*); M A I N

// F O N C T I O N main() {

// Variables locales afn_t *afn; afd_t *afd; // Cration de l'AFN afn = saisie_afn(); // Transformation de l'AFN afd = afn2afd(afn); // Affichage des resultats affiche_afd(afd); // Libration de la mmoire free_afn(afn); free_afd(afd); } void free_list(ptr_list_t p) { while (p) { ptr_list_t q = p; p = p->suiv; free(q); } } void free_afn(afn_t *afn) { ptr_trans_t q, p = afn->ltrans; free_list(afn->letat); free_list(afn->lsymb); while (p) { q = p; p = q->suiv; free_list(q->vers_e); free(q); } } void free_afd(afd_t *afd) { ptr_detat_t q1, p1 = afd->ldetat; ptr_dtrans_t q2, p2 = afd->ltrans; while (p1) { q1 = p1; p1 = q1->suiv; free_list(q1->letat); free(q1); }

free_list(afd->lsymb); while (p2) { q2 = p2; p2 = p2->suiv; free(q2); } } void list_inserer(ptr_list_t *ptr, int e) { ptr_list_t p = (ptr_list_t)malloc(sizeof(struct ptr_list)); p->info = e; p->suiv = 0; if (*ptr) { ptr_list_t q; for (q = *ptr; q->suiv; q = q->suiv); q->suiv = p; } else *ptr = p; } afn_t* saisie_afn() { int nbr_etat, nbr_symb, nbr, i, j, k, e; afn_t *afn; ptr_trans_t tr; afn = (afn_t*)malloc(sizeof(afn_t)); afn->letat = 0; afn->lsymb = 0; afn->ltrans = 0; // La list des etats printf("Dar el nmero de estados: "); scanf("%d", &nbr_etat); for (i = 0; i < nbr_etat; i++) list_inserer(&afn->letat, i); /* La list des symboles */ printf("Dar el numero de smbolos (sin contar el psilon): "); scanf("%d", &nbr_symb); for (i = 0; i < nbr_symb; i++) list_inserer(&afn->lsymb, i); // La list des transition for (i = 0; i < nbr_etat; i++) for (j = -1; j < nbr_symb; j++) { if (j == -1) printf("De '% d' el estado de estado de cmo se pu ede lograr con el smbolo de epsilon: ", i); else printf("De '% d' el estado de estado de cmo se pu ede lograr con la c%: ", i, 'a' + j); scanf("%d", &nbr); if (nbr) { tr = (ptr_trans_t)malloc(sizeof(struct ptr_trans )); tr->e = i; tr->s = j;

tr->vers_e = 0; for (k = 0; k < nbr; k++) { printf("Usted puede alcanzar el estado? "); scanf("%d", &e); list_inserer(&tr->vers_e, e); } tr->suiv = afn->ltrans; afn->ltrans = tr; } } return (afn); } void affiche_afd(afd_t *afd) { ptr_detat_t d; ptr_list_t s; d = afd->ldetat; printf(" |"); for (s = afd->lsymb; s; s = s->suiv) printf(" %c |", 'a' + s->info); printf("\n"); for (d = afd->ldetat; d; d = d->suiv) { ptr_dtrans_t ldtr; printf("%c |", 'A' + d->e); for (ldtr = afd->ltrans; ldtr; ldtr = ldtr->suiv) if (ldtr->de == d->e) printf(" %c |", 'A' + ldtr->fe); printf("\n"); } } void afd_ajouter_etat(ptr_detat_t *ldetat, int e, ptr_list_t letat) { ptr_detat_t lde; ptr_list_t p; lde = (ptr_detat_t)malloc(sizeof(struct ptr_detat)); lde->e = e; lde->letat = 0; lde->suiv = 0; for (p = letat; p; p = p->suiv) list_inserer(&lde->letat, p->info); if (*ldetat) { ptr_detat_t q; for (q = *ldetat; q->suiv; q = q->suiv); q->suiv = lde; } else *ldetat = lde; } int is_in_list(ptr_list_t letat, int e) { ptr_list_t p;

for (p = letat; p; p = p->suiv) if (p->info == e) return (1); return (0); } int epsilon_arc(afn_t* afn, int se, int fe) { ptr_trans_t p; ptr_list_t q; for (p = afn->ltrans; p; p = p->suiv) if ((p->e == se) && (p->s == EPSILON)) for (q = p->vers_e; q; q = q->suiv) if (q->info == fe) return (1); return (0); } void empiler_etat(ptr_list_t *p, int e) { ptr_list_t q = (ptr_list_t)malloc(sizeof(struct ptr_list)); q->info = e; q->suiv = *p; *p = q; } int depiler_etat(ptr_list_t *letat) { int e; ptr_list_t p; if (*letat) { e = (*letat)->info; p = *letat; *letat = p->suiv; free(p); return (e); } else return (NOETAT); } ptr_list_t epsilon_fermeture(afn_t* afn, ptr_list_t T) { ptr_list_t p, e_f = 0, pile_etat = 0; int t; for (p = T; p; p = p->suiv) { /* Epsilon el cierre se inicializa a T * T/ list_inserer(&e_f, p->info); /* Mantenga todos los estados de T */ empiler_etat(&pile_etat, p->info); } /* Como la pila no est vaca */ while ((t = depiler_etat(&pile_etat)) != NOETAT) { for (p = afn->letat; p; p = p->suiv) { /* Para cada Estado u con un arco de ta u psilon etiquite */ /* u = p->e*/

if (epsilon_arc(afn, t, p->info)) { /* Si usted no pertenece a la psilon de cierre T */ if (!is_in_list(e_f, p->info)) { /* Aadir a la clausura de la psilon T */ list_inserer(&e_f, p->info); /* Se apilan en el uso de la pila */ empiler_etat(&pile_etat, p->info); } } } } return (e_f); } void afd_ajouter_trans(ptr_dtrans_t *ltrans, int de, int fe, int s) { ptr_dtrans_t dtrans = (ptr_dtrans_t)malloc(sizeof(struct ptr_dtrans)); dtrans->de = de; dtrans->fe = fe; dtrans->s = s; dtrans->suiv = 0; if (*ltrans) { ptr_dtrans_t q; for (q = *ltrans; q->suiv; q = q->suiv); q->suiv = dtrans; } else *ltrans = dtrans; } int afd_trouve_etat(afd_t *afd, ptr_list_t letat) { ptr_detat_t dp; ptr_list_t dp_le, dp_e; for (dp = afd->ldetat; dp; dp = dp->suiv) { int nbr_element = 0; /* Hay igual nmero de elementos */ for (dp_e = dp->letat; dp_e; dp_e = dp_e->suiv, nbr_element++); for (dp_le = letat; dp_le; dp_le = dp_le->suiv, nbr_element--); if (nbr_element == 0) { for (dp_e = dp->letat; dp_e; dp_e = dp_e->suiv) { int trouve = 0; for (dp_le = letat; dp_le; dp_le = dp_le->suiv) if (dp_le->info == dp_e->info) { trouve = 1; break; } if (trouve == 0) return (NOETAT); }

return (dp->e); } } return (NOETAT); } ptr_list_t transiter(afn_t* afn, ptr_list_t letat, int s) { ptr_list_t p, q, tran = 0; ptr_trans_t tr; for (p = letat; p; p = p->suiv) for (tr = afn->ltrans; tr; tr = tr->suiv) if ((tr->e == p->info) && (tr->s == s)) for (q = tr->vers_e; q; q = q->suiv) list_inserer(&tran, q->info); return (tran); } afd_t* afn2afd(afn_t *afn) { afd_t *afd; ptr_list_t L = 0, U, s; ptr_detat_t p; int ee, e = 0; afd = (afd_t*)malloc(sizeof(afd_t)); afd->ldetat = 0; afd->lsymb = 0; afd->ltrans = 0; /* La AFN y AFD los mismos smbolos */ for (s = afn->lsymb; s; s = s->suiv) list_inserer(&afd->lsymb, s->info); list_inserer(&L, 0); U = epsilon_fermeture(afn, L); afd_ajouter_etat(&afd->ldetat, e++, U); for (p = afd->ldetat; p; p = p->suiv) { for (s = afn->lsymb; s; s = s->suiv) { /* Limpieza de la memoria mquinas */ free_list(L); free_list(U); L = transiter(afn, p->letat, s->info); U = epsilon_fermeture(afn, L); ee = afd_trouve_etat(afd, U); if (ee == NOETAT) { /* Dale un nombre */ ee = e++; afd_ajouter_etat(&afd->ldetat, ee, U); } afd_ajouter_trans(&afd->ltrans, p->e, ee, s->info); } } free_list(L); free_list(U); return (afd);