/*************************************** * * * Copyright (c) 1998 Jean-Eric Pin * * All rights reserved. * * * * TAB = 2 spaces * * * ***************************************/ /*------------------------------------------------------------------- * Memoire.c Jean-Eric Pin 07/12/96 *------------------------------------------------------------------- */ #include <stdlib.h> #include <stdio.h> #include <memory.h> #include "Main.h" #include "Globales.h" #include "Initialisation.h" #include "Inverses.h" #include "Matrices.h" #include "MatricesBooleennes.h" #include "MatricesMaxPlus.h" #include "Memoire.h" #include "Transitions.h" #include "Utilitaires.h" #ifdef DEBUG extern long ElementsAlloues; #endif /* DEBUG */ extern numero *TableDeHachage; /* La table de l'adresse des elements. On y accede par hachage et adressage ouvert. */ extern numero *TableIdempotents; /* La table des idempotents */ extern numero NbElements, TailleMaxi, NbRclasses; extern unsigned long TailleTableDeHachage; extern info **PointeurDeTable; extern info *Table; extern info2 *Table2; extern ProduitsDG *TableInfo; extern lettre *Mot; extern unsigned short NbEtats, NbLettres, LongueurMax, TypeSemigroupe, CalculsEffectues, MemoireAllouee, InitiauxASpecifer, FinauxASpecifer; extern element Identite; extern element *Generateurs; extern element *TableDesValeurs; /* Les valeurs des elements du semigroupe dans l'univers. */ extern Alloue_ AlloueMemoireElement; extern Libere_ LibereMemoireElement; extern char **Messages; extern infoSommet **Graphe; /* Le graphe syntactique */ extern Liste2Numeros PileGraphe; /* Pile utilisee pour le parcours en profondeur du graphe. */ extern numero **TableDeS; /* La table de multiplication du semigroupe */ extern short *EtatsInitiaux, *EtatsFinaux; extern struct NumeroEtLettre *PileInverses; extern ListeNumero *Inverses, *InversesFaibles; extern adresses Adresses; /**************************************************** * * AlloueMemoireAdresses. OK * ****************************************************/ void AlloueMemoireAdresses(void) { Adresses.commutatif_1 = (lettre *)malloc(sizeof(lettre)); if (Adresses.commutatif_1 == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.commutatif_2 = (lettre *)malloc(sizeof(lettre)); if (Adresses.commutatif_2 == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.idempotent = (numero *)malloc(sizeof(numero)); if (Adresses.idempotent == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.aperiodique = (numero *)malloc(sizeof(numero)); if (Adresses.aperiodique == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.DA_x = (numero *)malloc(sizeof(numero)); if (Adresses.DA_x == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.DA_y = (numero *)malloc(sizeof(numero)); if (Adresses.DA_y == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.RvL_x = (numero *)malloc(sizeof(numero)); if (Adresses.RvL_x == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.RvL_y = (numero *)malloc(sizeof(numero)); if (Adresses.RvL_y == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.RvL_z = (numero *)malloc(sizeof(numero)); if (Adresses.RvL_z == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.L1_s = (numero *)malloc(sizeof(numero)); if (Adresses.L1_s == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.L1_e = (numero *)malloc(sizeof(numero)); if (Adresses.L1_e == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.LG_e = (numero *)malloc(sizeof(numero)); if (Adresses.L1_e == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.LG_s = (numero *)malloc(sizeof(numero)); if (Adresses.L1_s == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1_p = (numero *)malloc(sizeof(numero)); if (Adresses.B1_p == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1_q = (numero *)malloc(sizeof(numero)); if (Adresses.B1_q == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1_r = (numero *)malloc(sizeof(numero)); if (Adresses.B1_r == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1_s = (numero *)malloc(sizeof(numero)); if (Adresses.B1_s == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1_e = (numero *)malloc(sizeof(numero)); if (Adresses.B1_e == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1_f = (numero *)malloc(sizeof(numero)); if (Adresses.B1_f == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1Plus_e = (numero *)malloc(sizeof(numero)); if (Adresses.B1Plus_e == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.B1Plus_s = (numero *)malloc(sizeof(numero)); if (Adresses.B1Plus_s == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.ECom_e = (numero *)malloc(sizeof(numero)); if (Adresses.ECom_e == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.ECom_f = (numero *)malloc(sizeof(numero)); if (Adresses.ECom_f == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.BG_e = (numero *)malloc(sizeof(numero)); if (Adresses.BG_e == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } Adresses.BG_f = (numero *)malloc(sizeof(numero)); if (Adresses.BG_f == NULL) { printf("%s \n", Messages[M_Pb_memory]); exit(1); } } /**************************************************** * * LibereMemoireAdresses. OK * ****************************************************/ void LibereMemoireAdresses(void) { free(Adresses.commutatif_1); free(Adresses.commutatif_2); free(Adresses.idempotent); free(Adresses.aperiodique); free(Adresses.DA_x); free(Adresses.DA_y); free(Adresses.RvL_x); free(Adresses.RvL_y); free(Adresses.RvL_z); free(Adresses.L1_e); free(Adresses.L1_s); free(Adresses.LG_e); free(Adresses.LG_s); free(Adresses.B1_p); free(Adresses.B1_q); free(Adresses.B1_r); free(Adresses.B1_s); free(Adresses.B1_e); free(Adresses.B1_f); free(Adresses.B1Plus_e); free(Adresses.B1Plus_s); free(Adresses.ECom_e); free(Adresses.ECom_f); free(Adresses.BG_e); free(Adresses.BG_f); } /**************************************************** * * AlloueMemoireProduits. OK * Necessite de connaitre le nombre de lettres * ****************************************************/ ProduitsDG *AlloueMemoireProduits(void) { register ProduitsDG *Produits; Produits = ALLOC(ProduitsDG, NbLettres); if (Produits == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_products]); /* Probleme lors de l'allocation memoire des produits */ exit(1); } return Produits; } /**************************************************** * * AlloueMemoireGenerateurs. OK * ****************************************************/ void AlloueMemoireGenerateurs(void) { lettre a; if (!(MemoireAllouee & MEMOIRE_GENERATEURS)) { Generateurs = ALLOC(element, NbLettres); if (Generateurs == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_generators]); /* Probleme lors de l'allocation memoire des generateurs */ exit(1); } for (a = 0; a < NbLettres; a++) Generateurs[a] = AlloueMemoireElement(); MemoireAllouee |= MEMOIRE_GENERATEURS; /* On prend note : on a alloue de la memoire aux generateurs. */ } #ifdef DEBUG else printf("La memoire des generateurs est deja allouee !\n"); #endif /* DEBUG */ } /**************************************************** * * LibereMemoireGenerateurs. OK * ****************************************************/ void LibereMemoireGenerateurs(void) { lettre a; for (a = 0; a < NbLettres; a++) LibereMemoireElement(Generateurs[a]); free(Generateurs); } /*********************************************************************************** * * AlloueMemoireTableDesValeurs. OK * TableDesValeurs[1] donne l'identite. * S'il y a 2 generateurs, leurs valeurs seront stockees * en TableDesValeurs[2] et TableDesValeurs[3]. * * Cette procedure est necessairement appelee AVANT InitIdentite et InitGenerateurs() * ************************************************************************************/ void AlloueMemoireTableDesValeurs(void) { TableDesValeurs = ALLOC(element, 2 + TailleMaxi); if (TableDesValeurs == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table_elements]); /* Probleme lors de l'allocation memoire de la table des elements */ exit(1); } } /**************************************************** * * LibereMemoireTableDesValeurs. OK * ****************************************************/ void LibereMemoireTableDesValeurs(void) { unsigned long i; for (i = 1; i <= NbElements; i++) LibereMemoireElement(TableDesValeurs[i]); free(TableDesValeurs); } /**************************************************** * * AlloueMemoirePile. OK * ****************************************************/ elementpile *AlloueMemoirePile(void) { elementpile *Pile; Pile = ALLOC(elementpile, NbElements); if (Pile == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table]); /* Probleme lors de l'allocation memoire d'un tableau */ return 0; } return Pile; } /**************************************************** * * AlloueMemoirePileComposanteConnexe. OK * ****************************************************/ numero *AlloueMemoirePileComposanteConnexe(void) { numero *PileComposanteConnexe; PileComposanteConnexe = ALLOC(numero, NbElements + 1); /* +1, car on met une sentinelle en fond de pile */ if (PileComposanteConnexe == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table]); /* Probleme lors de l'allocation memoire d'un tableau */ return 0; } return PileComposanteConnexe; } /**************************************************** * * AlloueMemoireTableau. OK * ****************************************************/ numero *AlloueMemoireTableau(unsigned long Taille) { numero *Tableau; Tableau = ALLOC(numero, Taille); if (Tableau == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table]); /* Probleme lors de l'allocation memoire d'un tableau */ return 0; } return Tableau; } /**************************************************** * * AlloueMemoireTable. OK * ****************************************************/ info *AlloueMemoireTable(void) { info *Table; Table = ALLOC(info, 1 + TailleMaxi); if (Table == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table_elements]); /* Probleme lors de l'allocation memoire de la table des elements */ exit(1); } return(Table); } /**************************************************** * * AlloueMemoireTable2. OK * ****************************************************/ info2 *AlloueMemoireTable2(void) { info2 *Table2; Table2 = ALLOC(info2, 1 + NbElements); if (Table2 == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table_elements]); /* Probleme lors de l'allocation memoire de la table des elements */ exit(1); } return(Table2); } /********************************************************* * * AlloueMemoireMot. Ajoute la place pour terminer par '\0' * *********************************************************/ lettre *AlloueMemoireMot(short Longueur) { lettre *Mot; Mot = ALLOC(lettre, 1 + Longueur); /* Un de plus, pour terminer par '\0' */ if (Mot == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_word]); /* Probleme lors de l'allocation memoire d'un mot */ exit(1); } return(Mot); } /********************************************************************** * * AlloueMemoireChaine. * **********************************************************************/ char *AlloueMemoireChaine(short Longueur) { char *Chaine; Chaine = ALLOC(char, Longueur); if (Chaine == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_word]); /* Probleme lors de l'allocation memoire d'un mot. */ exit(1); } return(Chaine); } /********************************************************************** * * AlloueMemoireGraphe. Comme les indices partent de 1, * on prend un graphe de taille (1 + NbElements) * (1 + NbElements). * Les entrees Graphe[0][v] et Graphe[u][0] ne servent pas. * **********************************************************************/ void AlloueMemoireGraphe(void) { numero j; Graphe = ALLOC(infoSommet *, (1 + NbElements)); if (Graphe == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_graph]); /* Probleme lors de l'allocation memoire du graphe. */ exit(1); } for (j = 0; j < 1 + NbElements; j++) { Graphe[j] = ALLOC(infoSommet, 1 + NbElements); if (Graphe[j] == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_graph]); /* Probleme lors de l'allocation memoire du graphe. */ exit(1); } } } /********************************************************************** * * LibereMemoireGraphe. * **********************************************************************/ void LibereMemoireGraphe(void) { numero u, v; Liste2Numeros Temporaire; for (u = 0; u <= NbElements; u++) for (v = 0; v <= NbElements; v++) while (Graphe[u][v].Aretes != NULL) { Temporaire = Graphe[u][v].Aretes; Graphe[u][v].Aretes = Graphe[u][v].Aretes->suivant; free(Temporaire); } for (u = 0; u <= NbElements; u++) free(Graphe[u]); free(Graphe); } /**************************************************** * * AlloueMemoirePileGraphe. OK * ****************************************************/ Liste2Numeros AlloueMemoirePileGraphe(unsigned long Taille) { Liste2Numeros PileGraphe; PileGraphe = ALLOC(struct Wagon2Numeros, Taille); if (PileGraphe == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table]); /* Probleme lors de l'allocation memoire d'un tableau */ return 0; } return PileGraphe; } /**************************************************** * * AlloueMemoireArete. * ****************************************************/ Liste2Numeros AlloueMemoireArete(void) { Liste2Numeros Liste; Liste = ALLOC(struct Wagon2Numeros, 1); if (Liste == NULL) { printf("%s %s xxx\n", Messages[M_Pb_memory], Messages[M_Pb_graph]); /* Probleme lors de l'allocation memoire du graphe. */ exit(1); } return(Liste); } /**************************************************** * * AlloueMemoireTableDeS. * ****************************************************/ numero **AlloueMemoireTableDeS(void) { numero **Table; numero i; Table = ALLOC(numero *, 1 + NbElements); if (Table == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table]); /* Probleme lors de l'allocation memoire du graphe. */ exit(1); } for (i = 0; i <= NbElements; i++) { Table[i] = ALLOC(numero, 1 + NbElements); if (Table[i] == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table]); /* Probleme lors de l'allocation memoire du graphe. */ exit(1); } } return(Table); } /**************************************************** * * LibereMemoireTableDeS. * ****************************************************/ void LibereMemoireTableDeS(void) { numero i; for (i = 0; i <= NbElements; i++) free(TableDeS[i]); free(TableDeS); } /**************************************************** * * AlloueMemoirePileNumeroEtLettre. OK * ****************************************************/ struct NumeroEtLettre *AlloueMemoirePileNumeroEtLettre(void) { struct NumeroEtLettre *Pile; Pile = ALLOC(struct NumeroEtLettre, NbElements); if (Pile == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_table]); /* Probleme lors de l'allocation memoire d'un tableau */ return 0; } return Pile; } /********************************************************************** * * AlloueMemoireTableListeNumero. * **********************************************************************/ ListeNumero *AlloueMemoireTableListeNumero(void) { ListeNumero *Table; Table = ALLOC(ListeNumero, 1 + NbElements); /* Les indices commencent a 1 ... */ if (Table == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_liste]); /* Probleme lors de l'allocation memoire d'une liste. */ exit(1); } return(Table); } /**************************************************** * * AlloueMemoireWagonNumero. * ****************************************************/ ListeNumero AlloueMemoireWagonNumero(void) { ListeNumero Liste; Liste = ALLOC(struct WagonNumero, 1); if (Liste == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_graph]); /* Probleme lors de l'allocation memoire du graphe. */ exit(1); } return(Liste); } /********************************************************************** * * LibereMemoireTable. * **********************************************************************/ void LibereMemoireTable(ListeNumero *Table) { numero u; ListeNumero Temporaire; for (u = 0; u <= NbElements; u++) while (Table[u] != NULL) { Temporaire = Table[u]; Table[u] = Table[u]->suivant; free(Temporaire); } free(Table); } /********************************************************************** * * AlloueMemoireInitiaux. * **********************************************************************/ void AlloueMemoireInitiaux(void) { EtatsInitiaux = ALLOC(short, (1 + NbEtats)); /* Initialisation a 0 automatique */ if (EtatsInitiaux == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_initial_states]); /* Probleme lors de l'allocation memoire des etats initiaux. */ exit(1); } } /********************************************************************** * * AlloueMemoireFinaux. * **********************************************************************/ void AlloueMemoireFinaux(void) { EtatsFinaux = ALLOC(short, (1 + NbEtats)); /* Initialisation a 0 automatique */ if (EtatsFinaux == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_final_states]); /* Probleme lors de l'allocation memoire des etats finaux. */ exit(1); } } /********************************************************************** * * AlloueMemoireMessages. * **********************************************************************/ void AlloueMemoireMessages(void) { Messages = ALLOC(char *, M_Last_Line); if (Messages == NULL) { printf("%s %s\n", Messages[M_Pb_memory], Messages[M_Pb_messages]); /* Probleme lors de l'allocation memoire des messages. */ exit(1); } } /**************************************************** * * LibereMemoire. OK * free(TableDeHachage) est fait independamment * LibereMemoireGenerateurs() est inutile, car les * generateurs sont stockes dans la table des valeurs * ****************************************************/ void LibereMemoire(void) { numero i; LibereMemoireGenerateurs(); for (i = NbElements; i > 0; i--) free(Table[i].Produits); free(Table[0].Produits); /* i est de type unsigned long : si i vaut 0, i-- est > 0 ! */ free(Table); free(Table2); LibereMemoireTableDesValeurs(); LibereMemoireAdresses(); if (CalculsEffectues & CALCUL_LISTE_IDEMPOTENTS) free(TableIdempotents); if (CalculsEffectues & CALCUL_P) LibereMemoireGraphe(); if (CalculsEffectues & CALCUL_TABLE_DE_S) LibereMemoireTableDeS(); if (CalculsEffectues & CALCUL_INVERSES) { free(PileInverses); LibereMemoireTable(Inverses); LibereMemoireTable(InversesFaibles); } if (CalculsEffectues & CALCUL_P) free(PileGraphe); if (InitiauxASpecifer) free(EtatsInitiaux); if (FinauxASpecifer) free(EtatsFinaux); #ifdef DEBUG printf("Elements Alloues : %ld \n", ElementsAlloues); #endif /* DEBUG */ }