fichier unique et réponse aléatoire

**emmesse** · 21/01/2023, 18h00

Bonjour,

j'ai un programme qui réagit de manière différentes alor que le fichier des données est le même (fichier nommé annulable)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
A epsilon\
A v b n\
v epsilon\
n epsilon\
#

chacune de ces lignes est une production
le premier mot de la ligne est la tête de production. les autres constituent le corps et la production se termine par antislash.
l'ensemble des productions se termine par dièse.

les non-terminaux sont A, v et n. les terminaux sont epsilon et b.

lorsque je lance le programme, des fois ça marche (ça marche si il n'affiche rien) et des fois ça met erreur de segmentation.

le débogueur gdb me dit que ça marche toujours

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include "syntaxique.hpp"
 
int main(int argc,char *argv[]){
  if(argc<2)
    std::cout<<"argument manquant"<<std::endl;
  else{
    syntaxique S(argv[1]);
    S.sortie();
  }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
#include <vector>
#include <string>
#include <iostream>
#include "lexical.hpp"
#include "syntaxique.hpp"
#include "symboles.hpp"
#include "uniLex.hpp"
 
bool absent(std::vector<std::string>const &l,std::string const &s);
bool present(std::vector<std::string>const &l,std::string const &s);
 
syntaxique::syntaxique(char *nomfichier):L(nomfichier)/*,ecriresortie(true),
							recurs(false)*/{
  //pilerecurs.clear();
  a=L.anaLex();
  grammaire=Grammaire();
  //ax=true;
}
 
void syntaxique::consommer(terminal const &t){
  if(t==a.getLex())
    a=L.anaLex();
  else{
    std::cerr<<"Ligne "<<L.getLigne()<<": symbole "<<a.getLexeme()
	     <<" inattendu"<<std::endl;
    //ecriresortie=false;
  }
}
 
 
std::vector<production>syntaxique::Grammaire(){
  std::vector<production>restegrammaire_h,grammaire_s,
    restegrammaire_s;
  production production_s;
  production_s=Production();
  restegrammaire_h.push_back(production_s);
  restegrammaire_s=Restegrammaire(restegrammaire_h);
  consommer(diese);
  grammaire_s=restegrammaire_s;
  for(auto s:symboles)
    if(absent(nonterminaux,s))
      terminaux.push_back(s);
  return grammaire_s;
}
 
std::vector<production>syntaxique::
Restegrammaire(std::vector<production> restegrammaire_h){
  std::vector<production>restegrammaire1_h,restegrammaire_s,
    restegrammaire1_s;
  production production_s;
  if(a.getLex()==mot){
    production_s=Production();
    restegrammaire_h.push_back(production_s);
    restegrammaire1_h=restegrammaire_h;
    restegrammaire1_s=Restegrammaire(restegrammaire1_h);
    restegrammaire_s=restegrammaire1_s;
  }
  else
    restegrammaire_s=restegrammaire_h;
  return restegrammaire_s;
}
 
production syntaxique::Production(){
  production production_s;
  std::vector<std::string> corps_s;
  std::string tete_s;
  tete_s=Tete();
  production_s.settete(tete_s);
  corps_s=Corps();
  production_s.setcorps(corps_s);
  consommer(antislash);
  return production_s;
}
 
std::string syntaxique::Tete(){
  std::string tete_s,mot_s;
  mot_s=a.getLexeme();
  consommer(mot);
  if(absent(symboles,mot_s))
    symboles.push_back(mot_s);
  if(absent(nonterminaux,mot_s))
     nonterminaux.push_back(mot_s);
  tete_s=mot_s;
  return tete_s;
}
 
std::vector<std::string> syntaxique::Corps(){
  std::string mot_s;
  std::vector<std::string> restecorps_h,corps_s,restecorps_s;
  mot_s=a.getLexeme();
  consommer(mot);
  if(absent(symboles,mot_s))
    symboles.push_back(mot_s);
  restecorps_h.push_back(mot_s);
  restecorps_s=Restecorps(restecorps_h);
  corps_s=restecorps_s;
  return corps_s;
}
 
std::vector<std::string> syntaxique::
Restecorps(std::vector<std::string>restecorps_h){
  std::vector<std::string> restecorps1_h,restecorps1_s,restecorps_s;
  std::string mot_s;
  if(a.getLex()==mot){
    mot_s=a.getLexeme();
    if(absent(symboles,mot_s))
      symboles.push_back(mot_s);
    consommer(mot);
    restecorps_h.push_back(mot_s);
    restecorps1_h=restecorps_h;
    restecorps1_s=Restecorps(restecorps1_h);
    restecorps_s=restecorps1_s;
  }
  else
    restecorps_s=restecorps_h;
  return restecorps_s;
}
 
void syntaxique::deuxannulables(){
  int n_annulables;
  std::vector<production> listep;
  for(auto nt:nonterminaux){
    n_annulables=0;
    listep=tetescommunes(nt);
    for(auto p:listep)
      if(annulable(p.getcorps())){
	n_annulables++;
	if(n_annulables>1){
	  std::cerr<<"plus d'un annulable avec "<<p.gettete()<<std::endl;
	  break;
	}
      }
  }
}
 
std::vector<production>syntaxique::tetescommunes(std::string t){
  std::vector<production>retour;
  for(auto p:grammaire)
    if(p.gettete()==t)
      retour.push_back(p);
  return retour;
}
 
bool syntaxique::annulable(std::vector<std::string> c){
  std::vector<production>communes;
  std::vector<std::string> pcorps;
  if(c[0]=="epsilon")
    return true;
  else
    for(auto s:c)
      if(present(terminaux,s)&&s!="epsilon")
	return false;
      else{
	communes=tetescommunes(s);
	for(auto p:communes){
	  pcorps=p.getcorps();
	  if( ! annulable(pcorps))
	    return false;
	}
      }
  return true;
}
 
void syntaxique::sortie(){
  deuxannulables();
}
 
void production::settete(std::string const &t){
  tete=t;
}
 
std::string production::gettete(){
  return tete;
}
 
void production::setcorps(std::vector<std::string> const &c){
  corps=c;
}
 
std::vector<std::string>production::getcorps(){
  return corps;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <string>
#include <vector>
#include <map>
#include "uniLex.hpp"
#include "lexical.hpp"
#include "symboles.hpp"
 
class production;
 
class syntaxique{
public:
  syntaxique(char *nomfichier);
  void consommer(terminal const &t);
  std::vector<production>Grammaire();
  std::vector<production>
  Restegrammaire(std::vector<production>restegrammaire_h);
  production Production();
  std::vector<std::string> Corps();
  std::vector<std::string> Restecorps(std::vector<std::string>restecorps_h);
  std::string Tete();
  void sortie();
  void deuxannulables();
  std::vector<production>tetescommunes(std::string t);
  bool annulable(std::vector<std::string> c);
private:
  //bool ax;
  lexical L;
  uniLex a;
  std::vector<std::string>symboles;
  std::vector<std::string>nonterminaux;
  std::vector<std::string>terminaux;
  std::vector<production>grammaire;
  bool ecriresortie,recurs;
};
 
class production{
public:
  void settete(std::string const &t);
  std::string gettete();
  void setcorps(std::vector<std::string> const &c);
  std::vector<std::string>getcorps();
private:
  std::string tete;
  std::vector<std::string> corps;
};

quelqu'un a une idée?

**Obsidian** · 23/01/2023, 04h02

Bonjour,
Ces symptômes sont relativement courants mais ici, ils peuvent vraiment être dus à n'importe quoi.

C'est une bonne chose de nous avoir donné le contenu des fichiers concernés mais ceux-ci s'appuient eux-mêmes sur les classes définies par lexical, symboles et uniLex (cpp et hpp). Donc le bug peut tout aussi bien venir de là également et cela nous empêche de compiler ton programme de notre côté pour le localiser.

Si tu utilises gdb, utilise la commande « bt » (backtrace) pour obtenir la pile des appels. Si tu utilises g++, N'oublie pas non plus de compiler tes programmes avec l'option « -g » pour y intégrer les informations de débogage.

Par ailleurs, ton programme est assez difficile à lire. Je t'encourage fortement à soigner la mise en forme car ça devient crucial en C++ et le faire permet souvent d'avoir une meilleure vue de ses propres algorithmes. Bien souvent, cela suffit à isoler les potentiels problèmes.

En tout état de cause, je vois déjà au moins un bloc :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
std::vector<production>
syntaxique::Restegrammaire(std::vector<production> restegrammaire_h)
{
    std::vector<production>     restegrammaire1_h,
                                restegrammaire_s,
                                restegrammaire1_s;

    production production_s;
    if(a.getLex()==mot)
    {
        production_s        = Production();

        restegrammaire_h.push_back(production_s);
        restegrammaire1_h   = restegrammaire_h;
        restegrammaire1_s   = Restegrammaire(restegrammaire1_h);
        restegrammaire_s    = restegrammaire1_s;
    }
    else restegrammaire_s = restegrammaire_h;

    return restegrammaire_s;
}

Tu utilises une récursion ici. Elle est peut-être légitime mais partout où tu en mets, il faut t'assurer que la condition d'arrêt est bien détectée et respectée. En outre, tu déclares trois nouveaux vecteurs à chaque ré-entrée, ce qui finit par être assez lourd en soi et qui peut conduire à une inflation exponentielle de l'espace utilisée dans la pile. Toutes ces choses peuvent provoquer des débordements de pile ou dépassement de buffer, et conduire à des segfaults.

L'autre grande cause des segfaults est l'utilisation de pointeurs mal initialisés. Je n'en vois pas dans les extraits présentés ici mais il faudrait voir le reste pour pouvoir exclure cette possibilité.

**koala01** · 23/01/2023, 07h19

Salut,
Outre ce qu'a dit Obsidian (et pour quoi je suis entièrement d'accord), je remarque que tu n'utilises absolument jamais les références, que tu passes, quasiment systématiquement, tes paramètres par valeurs, et que tu renvoie systématiquement les valeurs de retours de la même manière.

Le problème, c'est que cela occasionne systématiquement une copie de l'élément passé en argument / renvoyé avec tout ce que cela implique. Or, il s'agit très souvent de collections d'objets (std::vector<std::string> ou std::vector<production>), ce qui implique une sur-consommation (potentiellement) énorme de mémoire (car il faut copier la collection avec tout son contenu), une perte de temps potentiellement énorme ( pour la même raison) et énormément d'autres problèmes susceptibles d'apparaitre du fait même de cette copie.

Tu serais vraiment bien inspiré d'envisager de passer tous tes arguments sous la forme d'une référence -- éventuellement constante si tu ne veux pas que la valeur originale soit modifiée -- dés que la donnée nécessite plus d'espace en mémoire que pour représenter une donnée de type primitif (char, short, int, long, long long, float, double, long double, donc, pour faire simple, dés que sizeof(Untype) est supérieur à sizeof(long long) ).

De plus, les accesseurs (getXXX) devraient s'engager à ne pas modifier l'état courant de l'objet à partir duquel ils sont appelé, pour que le compilateur accepte, justement, de les appeler à partir de données constantes.
Pour ce faire, il "suffit" de les déclarer constant sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class MaClasse{
public:
    Type  getXXX () const; //une fonction constante renvoyant une donnée de type Type 
};

Cela peut également t'aider à mettre en évidence pas mal de problème

Enfin, il faut savoir qu'il ne suffit pas de placer une donnée en accessibilité privée et d'ajouter un accesseur (getXXX) et un mutateur (setXXX) pour obtenir une encapsulation correcte.

A vrai dire, en faisant cela, tu n'encapsule absolument rien et tu perds plus de temps qu'autre chose.

Si tu as un type de donnée dont le seul but est réellement de mettre deux ou plusieurs données en commun pour qu'elles soient simplement "plus facilement accessibles ensembles", tu n'as absolument aucun besoin de placer ces données dans un niveau d'accessibilité restreint, et tu peux même carrément te contenter d'en faire une structure sous une forme qui pourrait ressembler à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct production{
    std::string tete;
    std::vector<std::string> code;
};

**emmesse** · 23/01/2023, 11h12

et comme ceci:

annulable:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
A
epsilon\

A
v b n\

v
epsilon\

n
epsilon\
#

lexical.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
#include <iostream>
#include "uniLex.hpp"
#include "scanneur.hpp"
#include "lexical.hpp"
#include "symboles.hpp"
 
lexical::lexical(char *nomFichier):reussi(false),continuer(true),
				   scan(nomFichier),ligne(1),etat(0),
				   debutLex(0),lexeme("") { }
 
uniLex lexical::anaLex(){
  etat=debutLex=0;
  reussi=false;
  continuer=true;
  lexeme="";
  while(true){
    obtenirBlanc();
    if(reussi)
      continue;
    else
      echec();
 
    obtenirCommentaires();
    if(reussi)
      continue;
    else
      echec();
 
    obtenirMot();
    if(reussi)
      break;
    else
      echec();
 
    obtenirDiese();
    if(reussi)
      break;
    else
      echec();
 
    obtenirAntislash();
    if(reussi)
      break;
    else
      echec();
 
    obtenirDolar();
    if(reussi)
      continue;
    else
    echec();
 
    std::cerr<<ligne<<" "<<scan.carSuiv()<<" : symbole hors langage"
	     <<std::endl;
    exit(3);
  }
  return uniLexTrouve;
}
 
int lexical::getLigne(){
  return ligne;
}
 
void lexical::echec(){
  scan.reculer(debutLex);
  etat=debutLex=0;
  reussi=false;
  continuer=true;
  lexeme="";
}
 
void lexical::obtenirBlanc(){
  reussi=false;
  continuer=true;
  etat=0;
  debutLex=0;
  while(continuer){
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='\n'){
	ligne++;
	etat=1;
      }
      else if(c=='\t'||c==' ')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      c=scan.carSuiv();
      debutLex++;
      if(c=='\n'){
	ligne++;
	etat=1;
      }
      else if(c=='\r'||c=='\t'||c==' ')
	etat=1;
      else
	etat=2;
      break;
    case 2:
      scan.reculer(1);
      reussi=true;
      continuer=false;
      break;
    }
  }
}
 
void lexical::obtenirCommentaires(){
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='|')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      c=scan.carSuiv();
      debutLex++;
      if(c=='|')
	etat=2;
      else
	etat=1;
      break;
    case 2:
      continuer=false;
      reussi=true;
    }
}
 
 
 
void lexical::obtenirMot(){
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c>='a'&&c<='z'||c>='A'&&c<='Z'){
	lexeme+=c;
	etat=1;
      }
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      c=scan.carSuiv();
      debutLex++;
      if(c>='a'&&c<='z'||c>='A'&&c<='Z'||c>='0'&&c<='9'||c=='_'){
	lexeme+=c;
	etat=1;
      }
      else
	etat=2;
      break;
    case 2:
      scan.reculer(1);
      uniLexTrouve.valeur=mot;
      uniLexTrouve.attribut=lexeme;
      reussi=true;
      continuer=false;
      break;
    }
}
 
void lexical::obtenirDiese(){
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='#')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      uniLexTrouve.valeur=diese;
      continuer=false;
      reussi=true;
    }
}
 
void lexical::obtenirAntislash(){
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='\\')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      uniLexTrouve.valeur=antislash;
      continuer=false;
      reussi=true;
    }
}
 
void lexical::obtenirDolar(){
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c==EOF)
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      uniLexTrouve.valeur=dolar;
      continuer=false;
      reussi=true;
    }
}

lexical.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef LEXICAL_HPP
#define LEXICAL_HPP
#include <string>
#include "symboles.hpp"
#include "uniLex.hpp"
#include "scanneur.hpp"
 
class lexical{
public:
  lexical(char *nomFichier);
  uniLex anaLex();
  int getLigne();
  std::string strLex(terminal t);
private:
  char c;
  void obtenirBlanc();
  void obtenirCommentaires();
  void obtenirMot();
  void obtenirDiese();
  void obtenirAntislash();
  void obtenirDolar();
  void echec();
  bool reussi,continuer;
  uniLex uniLexTrouve;
  scanneur scan;
  int ligne,etat,debutLex;
  std::string lexeme;
};
 
#endif

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include "syntaxique.hpp"
 
int main(int argc,char *argv[]){
  if(argc<2)
    std::cout<<"argument manquant"<<std::endl;
  else{
    syntaxique S(argv[1]);
    //S.sortie();
  }
}

scanneur.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <fstream>
#include <iostream>
#include "scanneur.hpp"
 
scanneur::scanneur(std::string const& nomFichier):Ntampon(1),enAvant(0),
						  derniers(0){
  fichier.open(nomFichier.c_str(),std::ios::binary|std::ios::in);
  fichier.seekg(0,std::ios_base::end);
  tailleFichier=fichier.tellg();
  fichier.seekg(0,std::ios_base::beg);
  if(taille<=tailleFichier){
    fichier.read(tampon,taille);
    tampon[taille]=EOF;
  }
  else{
    derniers=tailleFichier;
    fichier.read(tampon,derniers);
    Ntampon=1;
    tampon[derniers]=EOF;
    enAvant=0;
  }
}
 
char scanneur::carSuiv(){
  if(tampon[enAvant]==EOF)
    if(enAvant!=taille)
      return tampon[enAvant++];//enAvant++ car on pourrait devoir reculer
    else if((Ntampon+1)*taille<=tailleFichier){//++ car tampon suivant
      fichier.read(tampon,taille);
      Ntampon++;
      enAvant=0;
      derniers=0;
      return tampon[enAvant++];
    }
    else{
      derniers=tailleFichier%(Ntampon*taille);
      fichier.read(tampon,derniers);
      Ntampon++;
      tampon[derniers]=EOF;
      enAvant=0;
      return tampon[enAvant++];
    }
  else
    return tampon[enAvant++];
}
 
void scanneur::reculer(int const &n){
  for(int i=0;i<n;i++){
    if(enAvant==0){
      if(Ntampon>1){
	fichier.seekg((Ntampon-2)*taille,std::ios_base::beg);
   	fichier.read(tampon,taille);
	enAvant=taille-1;
      }
      else if(derniers!=0)
	enAvant=derniers-1;
      else
	enAvant=taille-1;
      Ntampon--;
    }
    else
      enAvant--;
  }
}
 
int scanneur::getTailleFichier(){
  return tailleFichier;
}

scannaur.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#ifndef SCANNEUR_HPP
#define SCANNEUR_HPP
 
#include <fstream>
#include <string>
 
constexpr int taille=3;
 
class scanneur{
public:
  scanneur(std::string const& nomFichier);
  char carSuiv();
  void reculer(int const &n);
  int getTailleFichier();
private:
  std::ifstream fichier;
  char tampon[taille+1];// +1 car sentinelle EOF
  int Ntampon;
  int enAvant;
  int derniers;
  int tailleFichier;
};
 
#endif

symboles.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#ifndef SYMBOLES_HPP
#define SYMBOLES_HPP
 
constexpr int nbTermes=4;
enum terminal{antislash,diese,mot,dolar};
 
#endif

syntaxique.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <vector>
#include <string>
#include <iostream>
#include "lexical.hpp"
#include "syntaxique.hpp"
#include "symboles.hpp"
#include "uniLex.hpp"
 
bool absent(std::vector<std::string>const &l,std::string const &s);
bool present(std::vector<std::string>const &l,std::string const &s);
 
syntaxique::syntaxique(char *nomfichier):L(nomfichier)/*,ecriresortie(true),
							recurs(false)*/{
  //pilerecurs.clear();
  a=L.anaLex();
  grammaire=Grammaire();
  //ax=true;
}
 
void syntaxique::consommer(terminal const &t){
  if(t==a.valeur)
    a=L.anaLex();
  else{
    std::cerr<<"Ligne "<<L.getLigne()<<": symbole "<<a.attribut
	     <<" inattendu"<<std::endl;
    //ecriresortie=false;
  }
}
 
 
std::vector<std::vector<std::string>>syntaxique::Grammaire(){
  std::vector<std::vector<std::string>>restegrammaire_h,grammaire_s,
    restegrammaire_s;
  std::vector<std::string> production_s;
  production_s=Production();
  restegrammaire_h.push_back(production_s);
  restegrammaire_s=Restegrammaire(restegrammaire_h);
  consommer(diese);
  grammaire_s=restegrammaire_s;
  /*for(auto s:symboles)
    if(absent(nonterminaux,s))
    terminaux.push_back(s);*/
  return grammaire_s;
}
 
std::vector<std::vector<std::string>>syntaxique::
Restegrammaire(std::vector<std::vector<std::string>>
	       const &restegrammaire_h){
  std::vector<std::vector<std::string>>restegrammaire1_h,restegrammaire_s,
    copierestegrammaire_h(restegrammaire_h);
  std::vector<std::string> production_s;
  while(a.valeur==mot){
    production_s       =Production();
    copierestegrammaire_h.push_back(production_s);
    restegrammaire1_h  =copierestegrammaire_h;
  }
  restegrammaire_s=restegrammaire1_h;
  return restegrammaire_s;
}
 
std::vector<std::string> syntaxique::Production(){
  std::vector<std::string> production_s,resteproduction_h,resteproduction_s;
  std::string mot_unilex;
  mot_unilex=a.attribut;
  consommer(mot);
  resteproduction_h.push_back(mot_unilex);
  resteproduction_s   =Resteproduction(resteproduction_h);
  production_s        =resteproduction_s;
  consommer(antislash);
  return production_s;
}
 
std::vector<std::string> syntaxique::
Resteproduction(std::vector<std::string>const &resteproduction_h){
  std::vector<std::string>resteproduction1_h,resteproduction_s,
    copieresteproduction_h(resteproduction_h);
  std::string mot_unilex;
  while(a.valeur==mot){
    mot_unilex          = a.attribut;
    consommer(mot);
    copieresteproduction_h.push_back(mot_unilex);
    resteproduction1_h  = copieresteproduction_h;
  }
  resteproduction_s=resteproduction1_h;
  return resteproduction_s;
}

syntaxique.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <string>
#include <vector>
#include "uniLex.hpp"
#include "lexical.hpp"
#include "symboles.hpp"
 
class syntaxique{
public:
  syntaxique(char *nomfichier);
  void consommer(terminal const &t);
  std::vector<std::vector<std::string>>Grammaire();
  std::vector<std::vector<std::string>>
  Restegrammaire(std::vector<std::vector<std::string>>const
		 &restegrammaire_h);
  std::vector<std::string> Production();
  std::vector<std::string> Resteproduction(std::vector<std::string>
					   const &resteproduction_h);
private:
  lexical L;
  uniLex a;
  std::vector<std::vector<std::string>>grammaire;
};

unilex.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef UNILEX_HPP
#define UNILEX_HPP
 
#include <string>
#include "symboles.hpp"
 
class uniLex{
public:
  terminal valeur;
  std::string attribut;
};
 
#endif

des fois ça met encore segfault mais des fis ça marche. Comme avant.

voici ce que me dit systématiquement gdb:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
(gdb) r
Starting program: /media/mathieu/MyPassport/espace de travail/premsEtSuiv10/analyseLL-2.0/pourdevelnet/a.out annulables
[Inferior 1 (process 6639) exited normally]

sinon, ça marche à chaque fois avec ce fichier d'entrée:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
E
T Eprim\

Eprim
plus T Eprim\

Eprim
epsilon\

T
F Tprim\

Tprim
etoile F Tprim\

Tprim
epsilon\

F
id\

F
nb\

F
po E pf\
#

**emmesse** · 23/01/2023, 14h08

Victoire!

ça y est, ça marche à tous les coups, je n'ai plus de segfault. Il falait changer l'atribut état de la classe lexical en variable locale dans les méthodes obtenirblanc, obtenircommentaire, obtenirmot, obtenirdiese, obtenirantislash et obtenirdolar.

lexical.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
#include <iostream>
#include "uniLex.hpp"
#include "scanneur.hpp"
#include "lexical.hpp"
#include "symboles.hpp"
 
lexical::lexical(char *nomFichier):reussi(false),continuer(true),
				   scan(nomFichier),ligne(1),
				   debutLex(0),lexeme("") { }
 
uniLex lexical::anaLex(){
  debutLex=0;
  reussi=false;
  continuer=true;
  lexeme="";
  while(true){
    obtenirBlanc();
    if(reussi)
      continue;
    else
      echec();
 
    obtenirCommentaires();
    if(reussi)
      continue;
    else
      echec();
 
    obtenirMot();
    if(reussi)
      break;
    else
      echec();
 
    obtenirDiese();
    if(reussi)
      break;
    else
      echec();
 
    obtenirAntislash();
    if(reussi)
      break;
    else
      echec();
 
    obtenirDolar();
    if(reussi)
      continue;
    else
    echec();
 
    std::cerr<<ligne<<" "<<scan.carSuiv()<<" : symbole hors langage"
	     <<std::endl;
    exit(3);
  }
  return uniLexTrouve;
}
 
int lexical::getLigne()const{
  return ligne;
}
 
void lexical::echec(){
  scan.reculer(debutLex);
  debutLex=0;
  reussi=false;
  continuer=true;
  lexeme="";
}
 
void lexical::obtenirBlanc(){
  int etat=0;
  reussi=false;
  continuer=true;
  etat=0;
  debutLex=0;
  while(continuer){
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='\n'){
	ligne++;
	etat=1;
      }
      else if(c=='\t'||c==' ')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      c=scan.carSuiv();
      debutLex++;
      if(c=='\n'){
	ligne++;
	etat=1;
      }
      else if(c=='\r'||c=='\t'||c==' ')
	etat=1;
      else
	etat=2;
      break;
    case 2:
      scan.reculer(1);
      reussi=true;
      continuer=false;
      break;
    }
  }
}
 
void lexical::obtenirCommentaires(){
  int etat=0;
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='|')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      c=scan.carSuiv();
      debutLex++;
      if(c=='|')
	etat=2;
      else
	etat=1;
      break;
    case 2:
      continuer=false;
      reussi=true;
    }
}
 
 
 
void lexical::obtenirMot(){
  int etat=0;
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c>='a'&&c<='z'||c>='A'&&c<='Z'){
	lexeme+=c;
	etat=1;
      }
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      c=scan.carSuiv();
      debutLex++;
      if(c>='a'&&c<='z'||c>='A'&&c<='Z'||c>='0'&&c<='9'||c=='_'){
	lexeme+=c;
	etat=1;
      }
      else
	etat=2;
      break;
    case 2:
      scan.reculer(1);
      uniLexTrouve.valeur=mot;
      uniLexTrouve.attribut=lexeme;
      reussi=true;
      continuer=false;
      break;
    }
}
 
void lexical::obtenirDiese(){
  int etat=0;
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='#')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      uniLexTrouve.valeur=diese;
      continuer=false;
      reussi=true;
    }
}
 
void lexical::obtenirAntislash(){
  int etat=0;
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c=='\\')
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      uniLexTrouve.valeur=antislash;
      continuer=false;
      reussi=true;
    }
}
 
void lexical::obtenirDolar(){
  int etat=0;
  while(continuer)
    switch(etat){
    case 0:
      c=scan.carSuiv();
      debutLex++;
      if(c==EOF)
	etat=1;
      else{
	reussi=false;
	continuer=false;
      }
      break;
    case 1:
      uniLexTrouve.valeur=dolar;
      continuer=false;
      reussi=true;
    }
}

lexical.hpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef LEXICAL_HPP
#define LEXICAL_HPP
#include <string>
#include "symboles.hpp"
#include "uniLex.hpp"
#include "scanneur.hpp"
 
class lexical{
public:
  lexical(char *nomFichier);
  uniLex anaLex();
  int getLigne()const;
  std::string strLex(terminal t);
private:
  char c;
  void obtenirBlanc();
  void obtenirCommentaires();
  void obtenirMot();
  void obtenirDiese();
  void obtenirAntislash();
  void obtenirDolar();
  void echec();
  bool reussi,continuer;
  uniLex uniLexTrouve;
  scanneur scan;
  int ligne,debutLex;
  std::string lexeme;
};
 
#endif

main.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include "syntaxique.hpp"
 
int main(int argc,char *argv[]){
  if(argc<2)
    std::cout<<"argument manquant"<<std::endl;
  else{
    syntaxique S(argv[1]);
    //S.sortie();
  }
}

scanneur.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <fstream>
#include <iostream>
#include "scanneur.hpp"
 
scanneur::scanneur(std::string const& nomFichier):Ntampon(1),enAvant(0),
						  derniers(0){
  fichier.open(nomFichier.c_str(),std::ios::binary|std::ios::in);
  fichier.seekg(0,std::ios_base::end);
  tailleFichier=fichier.tellg();
  fichier.seekg(0,std::ios_base::beg);
  if(taille<=tailleFichier){
    fichier.read(tampon,taille);
    tampon[taille]=EOF;
  }
  else{
    derniers=tailleFichier;
    fichier.read(tampon,derniers);
    Ntampon=1;
    tampon[derniers]=EOF;
    enAvant=0;
  }
}
 
char scanneur::carSuiv(){
  if(tampon[enAvant]==EOF)
    if(enAvant!=taille)
      return tampon[enAvant++];//enAvant++ car on pourrait devoir reculer
    else if((Ntampon+1)*taille<=tailleFichier){//++ car tampon suivant
      fichier.read(tampon,taille);
      Ntampon++;
      enAvant=0;
      derniers=0;
      return tampon[enAvant++];
    }
    else{
      derniers=tailleFichier%(Ntampon*taille);
      fichier.read(tampon,derniers);
      Ntampon++;
      tampon[derniers]=EOF;
      enAvant=0;
      return tampon[enAvant++];
    }
  else
    return tampon[enAvant++];
}
 
void scanneur::reculer(int const &n){
  for(int i=0;i<n;i++){
    if(enAvant==0){
      if(Ntampon>1){
	fichier.seekg((Ntampon-2)*taille,std::ios_base::beg);
   	fichier.read(tampon,taille);
	enAvant=taille-1;
      }
      else if(derniers!=0)
	enAvant=derniers-1;
      else
	enAvant=taille-1;
      Ntampon--;
    }
    else
      enAvant--;
  }
}
 
int scanneur::getTailleFichier(){
  return tailleFichier;
}

scanneur.hpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#ifndef SCANNEUR_HPP
#define SCANNEUR_HPP
 
#include <fstream>
#include <string>
 
constexpr int taille=3;
 
class scanneur{
public:
  scanneur(std::string const& nomFichier);
  char carSuiv();
  void reculer(int const &n);
  int getTailleFichier();
private:
  std::ifstream fichier;
  char tampon[taille+1];// +1 car sentinelle EOF
  int Ntampon;
  int enAvant;
  int derniers;
  int tailleFichier;
};
 
#endif

symboles.hpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#ifndef SYMBOLES_HPP
#define SYMBOLES_HPP
 
constexpr int nbTermes=4;
enum terminal{antislash,diese,mot,dolar};
 
#endif

syntaxique.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <vector>
#include <string>
#include <iostream>
#include "lexical.hpp"
#include "syntaxique.hpp"
#include "symboles.hpp"
#include "uniLex.hpp"
 
bool absent(std::vector<std::string>const &l,std::string const &s);
bool present(std::vector<std::string>const &l,std::string const &s);
 
syntaxique::syntaxique(char *nomfichier):L(nomfichier)/*,ecriresortie(true),
							recurs(false)*/{
  //pilerecurs.clear();
  a=L.anaLex();
  grammaire=Grammaire();
  //ax=true;
}
 
void syntaxique::consommer(terminal const &t){
  if(t==a.valeur)
    a=L.anaLex();
  else{
    std::cerr<<"Ligne "<<L.getLigne()<<": symbole "<<a.attribut
	     <<" inattendu"<<std::endl;
    //ecriresortie=false;
  }
}
 
 
std::vector<std::vector<std::string>>syntaxique::Grammaire(){
  std::vector<std::vector<std::string>>restegrammaire_h,grammaire_s,
    restegrammaire_s;
  std::vector<std::string> production_s;
  production_s=Production();
  restegrammaire_h.push_back(production_s);
  restegrammaire_s=Restegrammaire(restegrammaire_h);
  consommer(diese);
  grammaire_s=restegrammaire_s;
  /*for(auto s:symboles)
    if(absent(nonterminaux,s))
    terminaux.push_back(s);*/
  return grammaire_s;
}
 
std::vector<std::vector<std::string>>syntaxique::
Restegrammaire(std::vector<std::vector<std::string>>
	       const &restegrammaire_h){
  std::vector<std::vector<std::string>>restegrammaire1_h,restegrammaire_s,
    copierestegrammaire_h(restegrammaire_h);
  std::vector<std::string> production_s;
  while(a.valeur==mot){
    production_s       =Production();
    copierestegrammaire_h.push_back(production_s);
    restegrammaire1_h  =copierestegrammaire_h;
  }
  restegrammaire_s=restegrammaire1_h;
  return restegrammaire_s;
}
 
std::vector<std::string> syntaxique::Production(){
  std::vector<std::string> production_s,resteproduction_h,resteproduction_s;
  std::string mot_unilex;
  mot_unilex=a.attribut;
  consommer(mot);
  resteproduction_h.push_back(mot_unilex);
  resteproduction_s   =Resteproduction(resteproduction_h);
  production_s        =resteproduction_s;
  consommer(antislash);
  return production_s;
}
 
std::vector<std::string> syntaxique::
Resteproduction(std::vector<std::string>const &resteproduction_h){
  std::vector<std::string>resteproduction1_h,resteproduction_s,
    copieresteproduction_h(resteproduction_h);
  std::string mot_unilex;
  while(a.valeur==mot){
    mot_unilex          = a.attribut;
    consommer(mot);
    copieresteproduction_h.push_back(mot_unilex);
    resteproduction1_h  = copieresteproduction_h;
  }
  resteproduction_s=resteproduction1_h;
  return resteproduction_s;
}

syntaxique.hpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <string>
#include <vector>
#include "uniLex.hpp"
#include "lexical.hpp"
#include "symboles.hpp"
 
class syntaxique{
public:
  syntaxique(char *nomfichier);
  void consommer(terminal const &t);
  std::vector<std::vector<std::string>>Grammaire();
  std::vector<std::vector<std::string>>
  Restegrammaire(std::vector<std::vector<std::string>>const
		 &restegrammaire_h);
  std::vector<std::string> Production();
  std::vector<std::string> Resteproduction(std::vector<std::string>
					   const &resteproduction_h);
private:
  lexical L;
  uniLex a;
  std::vector<std::vector<std::string>>grammaire;
};

unilex.hpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef UNILEX_HPP
#define UNILEX_HPP
 
#include <string>
#include "symboles.hpp"
 
class uniLex{
public:
  terminal valeur;
  std::string attribut;
};
 
#endif

**emmesse** · 23/01/2023, 14h14

j'ai aussi fait passer la valeur du constexpr taille à 1024

**deedolith** · 23/01/2023, 21h54

Je me permettrai d'ajouter:
N'hésite pas à convertir les arguments de la fonction main en vrai objets C++, en l'occurrence std::string. Ce sera plus facile à manipuler, et t'éviteras de trimbaler ces horribles pointeurs nu:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int main(int argc, char* argv[])
{
	std::vector<std::string> args;
	for (unsigned i = 0; i < static_cast<unsigned>(argc); ++i)
		args.push_back(argv[i]);

fichier unique et réponse aléatoire

C++

Discussions similaires

Partager

Partager