résultats divers pour un même programme avec le même fichier de données.

[essemme]

Bonjour,

mon programme, avec le même fichier d'entrée, des fois il marche et des fois il me dit erreur de segmentation.

Le fichier d'entrée est le suivant:

A epsilon\
A v b n\
v epsilon\
n epsilon\
#

chaque ligne est une productions.
le premier identificateur d'une ligne est la tête de production. Les autre constituent le corps. Une production se termine ici par un antislash, et l'ensemble des productions (la grammaire) se termine par un dièse.
Ici, les non terminaux (les symboles utilisés pour les têtes de production) sont A,v et n.
les terminaux sont b et epsilon.

j'ai fait un programme (pour un projet qui dépasse un peu ce post) qui vérifie qu'une production annulable ne l'est pas pour plus d'un corps.
un non-terminal ne doit pas être la tête de plus d'une production dont le corps est epsilon ou une suite de symboles annulables.

lors que j'exécute ce programme, des fois ça marche (il ne doit rien répondre) et parfois ça me met erreur de segmentation, sans avoir modfié ni le programme, ni le fichier d'entrée

mon déboggeur ne détecte aucune anomalie à ce programme avec ce fichier d'entrée

j'ai essayé avec un autre ordinateur et pareil.

je précise que ce code fonctionne avec les autres fichiers d'entré


Voici le programme:
main.cpp

#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();
  }
}

syntaxique.hpp

#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);
  //std::vector<std::string>listeteteprod(std::vector<production> g);
  /*std::vector<production> productifs(std::vector<production>const
    &grammaire);*/
  //bool partie(std::vector<production>&prod,std::string const &alpha);
  //std::vector<production>normalise(std::vector<production> &prod);
  /*void deuxannulables(production const &p);
  std::vector<std::string>suivants(std::string const &n);
  std::vector<std::string>suivantsn(std::string const &s,int const &n);
  void ajoutersuivants(std::vector<std::string> const &v,
		       std::string const &s);
  void recursivitees(production const &A);
  void ambigue(production const &p);
  std::vector<production>commence(std::string const &recherche);
  std::string gettete();
  production quelleproduction(std::string const &t);
  std::vector<std::string> nonterminaux0(production const &A);
  bool annulable(std::string s);
  bool annulable(corps const &c);
  bool annulable(production const &p);
  bool annulable(std::vector<std::string>const & groupe);
  std::vector<std::string>premiers(std::string const &s);
  std::vector<std::string>premiers(std::vector<std::string>const & groupe);
  int comptersymboles(std::string const &s);
  void factorisable(production const &p);*/
private:
  //bool ax;
  lexical L;
  uniLex a;
  std::vector<std::string>symboles;
  std::vector<std::string>nonterminaux;
  std::vector<std::string>terminaux;
  /*std::vector<std::string>pilerecurs;
  std::vector<std::string>pastester;
  std::vector<std::string>pilesuivants,dejacalcule,encours;*/
  std::vector<production>grammaire;
  bool ecriresortie,recurs;
  /*std::map<std::string,std::vector<std::string>>tabsuivants;
  std::map<std::string,std::string>casevides;*/
};

class production{
public:
  bool annulable();
  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;
  };

/*class corps{
public:
  void clear();
  void ajoutermot(std::string const &m);
  std::string getelem(int const &n);
  int taille();
  std::vector<std::string>getcontenu();
  void setcontenu(std::vector<std::string> const &c);
private:
  std::vector<std::string> contenu;
};

class productionsimple{
public:
  std::string gettete();
  void settete(std::string t);
  std::vector<std::string> getcorps();
  void ajoutersymbole(std::string s);
private:
  std::string tete;
  std::vector<std::string> corpsseul;
};
*/

et syntaxique.cpp

#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){
  a=L.anaLex();
  grammaire=Grammaire();
}

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;
  }
}


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;
}

quelqu'un a une idée?
-----

[essemme]

je n'ai pas donné le syntaxique.hpp qui pose problème dans le dernier post:

syntaxique.hpp

#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:
  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:
  bool annulable();
  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;
};

[essemme]

laissez tomber,j'ai eu entre temps une grosse trouvaille. Je vous en parlerais demain.

[umfred]

bah alors tu nous a oublié ?

[A voir en vidéo sur Futura]

[essemme]

désolé pour le retard

j'ai supprimé les fonctions Tete() et Corps() car on peut considérer que la tête est toujours le premier mot de la ligne et le corps le reste de la ligne jusqu'à l'antislash.
j'ai changé l'appel récursif final dans Grammaire() et Production(). par des itérations. j'ai utilisé plus de paramètres en référence
j'ai changé les attributs "etat", "lexeme" et "continuer" en variables locales dans les fonctions obtenir... . Ce qui donne:

fichier "annulable":

A
epsilon\

A
v b n\

v
epsilon\

n
epsilon\
#

lexical.cpp:

#include <iostream>
#include "uniLex.hpp"
#include "scanneur.hpp"
#include "lexical.hpp"
#include "symboles.hpp"

lexical::lexical(char *nomFichier):reussi(false),scan(nomFichier),ligne(1),
				   debutLex(0) { }

uniLex lexical::anaLex(){
  debutLex=0;
  reussi=false;
  while(true){
    obtenirBlanc();
    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)
      break;
    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;
}

void lexical::obtenirBlanc(){
  int etat=0;
  bool continuer=true;
  std::string lexeme="";
  reussi=false;
  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::obtenirMot(){
  int etat=0;
  bool continuer=true;
  std::string lexeme="";
  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;
  bool continuer=true;
  std::string lexeme="";
  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;
  bool continuer=true;
  std::string lexeme="";
  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;
  bool continuer=true;
  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:

#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;
  uniLex uniLexTrouve;
  scanneur scan;
  int ligne,debutLex;
  std::string lexeme;
};

#endif

main.cpp

#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

#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()const{
  return tailleFichier;
}

scanneur.hpp:

#ifndef SCANNEUR_HPP
#define SCANNEUR_HPP

#include <fstream>
#include <string>

constexpr int taille=1024;

class scanneur{
public:
  scanneur(std::string const& nomFichier);
  char carSuiv();
  void reculer(int const &n);
  int getTailleFichier()const;
private:
  std::ifstream fichier;
  char tampon[taille+1];// +1 car sentinelle EOF
  int Ntampon;
  int enAvant;
  int derniers;
  int tailleFichier;
};

#endif

symboles.hpp

#ifndef SYMBOLES_HPP
#define SYMBOLES_HPP

constexpr int nbTermes=4;
enum terminal{antislash,diese,mot,dolar};

#endif

syntaxique.cpp

#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

#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;
};

unlex.hpp

#ifndef UNILEX_HPP
#define UNILEX_HPP

#include <string>
#include "symboles.hpp"

class uniLex{
public:
  terminal valeur;
  std::string attribut;
};

#endif