1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
typedef char* t_etats;
'etats' est une variable globale. Un tableau de 500 caractères maxi qui contiendra toute la ligne du fichier (espaces compris).
i est la variable qui permet de se déplacer dans ce tableau.
//////////////////////////////////////// FONCTION RECHERCHER_ETATS ///////////////////////////////////////////////
/*
* Recherche les états de la machine dans le fichier 'machine'.
* Préconditions : Le fichier existe
* Postconditions : Renvoie un tableau de chaîne de caractères (les états).
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
t_etats* rechercher_etats(FILE* fichier){
char marqueur = '$'; t_etats* etats_ret=NULL;
/* Parcours du fichier ligne par ligne. On sort de la boucle une fois le mot trouvé.*/
while (!feof(fichier)){
fgets(etats,sizeof(etats),fichier);
if(etats[0] != marqueur){
break;
}
}
printf("Etats recherches : %s",etats);
printf("Taille : %d\n",strlen(etats)-2); // on enlève le '#' et le marqueur de fin '\0'
int unsigned i=0; int j=0; int unsigned k=0; int maxetats=0; int taille_nom_etat=0; int t=0;
// On compte le nombre total d'états présents pour la machine. En comptant le nombre d'espace entre leurs noms et en ajoutant 1.
while(k<strlen(etats)-2){
if(etats[k]==' '){
maxetats++;
}
k++;
}
maxetats++;
printf("nbre d'etats : %d\n",maxetats);
/* tab_etat est un tableau de pointeurs. Sa taille (maxetats) n'est pas connue à l'avance. Mais, on en aura besoin un peu plus haut
* dans la fonction "indice_etat". Sa taille réelle est contenue dans la variable maxetats et on ajoute une case de plus qui
* contiendra toujours NULL. Cette case jouera le rôle de marqueur de fin et nous permettra à l'aide d'une boucle de déterminer la
* taille du tableau. Les indices vont de 0 à maxetats-1. Donc, si on ajoute une colonne de plus, elle aura pour indice 'maxetats'.
*/
t_etats tab_etat[maxetats+1]; tab_etat[maxetats]=NULL;
for(j=0;j<maxetats;j++){
/* On compte la taille en caracteres de chaque etat.
* strlen(mot)-2 pour éviter de prendre le dernier caractère de la chaine # et le marqueur de fin : '\0'.
*/
while(etats[i]!=' ' && i<strlen(etats)-2){
i++;
taille_nom_etat++;
}
printf("taille du nom de l'etat = %d\n",taille_nom_etat);
//size_t n = taille_nom_etat;
/*
* Pour chaque état, on alloue une zone mémoire de taille variable qui contiendra son nom (chaine de caractère qui le
* représente). Ceci, en partant du principe que les noms (des états) i.e les chaines de caractère sont de tailles différentes.
*
* Si par exemple, nous avons les états : 'etat1' 'etat2', 'e3', 'q4', 'eta5'
* On allouera :
* Une zone mémoire de 5 caractères pour chacun des états 1 et 2.
* Une zone de 2 caractères pour chacun des états 3 et 4 et
* Une zone de 4 caractères pour l'état 5.
* tab_etat est un tableau de pointeurs sur ces caractères. Donc,
* tab_etat[0] pointera sur l'état 1 et donc sur la chaîne : 'etat1'
* tab_etat[1] pointera sur l'état 2 et donc sur la chaîne : 'etat2'
* tab_etat[2] pointera sur l'état 3 et donc sur la chaîne : 'e2'
* tab_etat[3] pointera sur l'état 4 et donc sur la chaîne : 'q4'
* tab_etat[4] pointera sur l'état 5 et donc sur la chaîne : 'eta5'
*/
tab_etat[j] = malloc(sizeof(char)*taille_nom_etat);
if(tab_etat[j]==NULL){
printf("\n Allocation Impossible \n");
exit(EXIT_FAILURE);
}
//printf("i = %d\n",i);
int temp; temp = taille_nom_etat; int taille; taille = strlen(etats)-2;
if(i <= taille){
for(t=0;t<taille_nom_etat;t++){
tab_etat[j][t]=etats[i-temp];
temp--;
}
}
i++;
taille_nom_etat=0;
}
printf("Les etats sont : \n");
for(j=0;j<maxetats;j++){
printf("%s\n",tab_etat[j]);
}
//system("PAUSE");
printf("\n");
etats_ret = tab_etat;
return etats_ret;
}
// Fin de la fonction rechercher_etats |
