Discussion :

[emmesse]

Bonjour,

sur la capture d'écran, on voit p[1]="epsilon" et l'instruction de la ligne 273 du if se fait quand-même alors que la condition n'est pas vérifiée

j'utilise le deboggeur gdb

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
void grammaire::recursdirecte(std::string A){
  std::vector<std::vector<std::string>>retour;
  std::vector<std::string> X,Y;
  bool premieralpha=true;
  size_t indice=0;
  for(auto &p:grammaire_s)
    if(p[0]==A){
      if(p[1]==A)
	if( ! annulable(A) && premieralpha){
	  Y.push_back(A+"prim");
	  Y.push_back("epsilon");
	  retour.push_back(Y);
	  Y.clear();
	  premieralpha=false;
	}
	X.push_back(A+"prim");
	X.insert(X.end(),p.begin()+2,p.end());//alpha_n
	X.push_back(A+"prim");
	retour.push_back(X);
	X.clear();
      }
      else{
	X.push_back(A);
	if(p[1] != "epsilon")
	  X.insert(X.end(),p.begin()+1,p.end());//beta_n
	X.push_back(A+"prim");
	retour.push_back(X);
	X.clear();
      }
  for(size_t i=0;i<grammaire_s.size();i++)
    if(grammaire_s[i][0]==A){
      grammaire_s.erase(grammaire_s.begin()+i);
      i--;
    }
  grammaire_s.insert(grammaire_s.end(),retour.begin(),retour.end());
}

quelqu'un a une idée?

[emmesse]

c'est parce que j'ai compilé comme ça:

Code :

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

g++ -g -o direct *cpp

puis:

Code :

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

gdb --args ./a.out a-sa

du coup, le fichier source ne correspondait pas

[deedolith]

Salut,

Il va vraiment falloir que tu te mettes à écrire du code qui veuille dire quelque chose, à commencer par choisir des noms de variables pertinents.
Sérieusement, A, X, Y, P, ca ne veut rien dire, et Retour encore moins (ta fonction ne retourne rien).

De plus, en C++, on ne pré-déclare pas les variables, ca gaspille des ressources inutilement (aussi infimes soient-elles).
On déclare les variable là où on les utilises pour la première fois (et on les initialise au passage).

[emmesse]

@deedolith

il n'y a pas vraiment de retour, le résultat vient s'ajouter à grammaire_s

-------------------
une autre fonction, Rproductions
il faut donc que je redéclare la variable Rproductions_s à chaque scope du if-else?
et si je la déclarais avant le if?

version1:

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
#include <vector>
#include <string>
 
#include "grammaire.hpp"
#include "unilex.hpp"
 
std::vector<std::vector<std::string>> grammaire::Rproductions(std::vector<std::vector<std::string>> const &Rproductions_h){
  if(a.valeur==mot){
    std::vector<std::vector<std::string>>productions_s;
    productions_s=productions();
    std::vector<std::vector<std::string>>Rproductions1_h;
    Rproductions1_h=Rproductions_h;
    Rproductions1_h.insert(Rproductions1_h.end(),productions_s.begin(),productions_s.end());
    std::vector<std::vector<std::string>>Rproductions1_s;
    Rproductions1_s=Rproductions(Rproductions1_h);
    std::vector<std::vector<std::string>>Rproductions_s;
    Rproductions_s=Rproductions1_s;
    return Rproductions_s;
  }
  else{
    std::vector<std::vector<std::string>>Rproductions_s;
    Rproductions_s=Rproductions_h;
    return Rproductions_s;
  }
}

version 2:

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
#include <vector>
#include <string>
 
#include "grammaire.hpp"
#include "unilex.hpp"
 
std::vector<std::vector<std::string>> grammaire::Rproductions(std::vector<std::vector<std::string>> const &Rproductions_h){
  std::vector<std::vector<std::string>>Rproductions_s;
  if(a.valeur==mot){
    std::vector<std::vector<std::string>>productions_s;
    productions_s=productions();
    std::vector<std::vector<std::string>>Rproductions1_h;
    Rproductions1_h=Rproductions_h;
    Rproductions1_h.insert(Rproductions1_h.end(),productions_s.begin(),productions_s.end());
    std::vector<std::vector<std::string>>Rproductions1_s;
    Rproductions1_s=Rproductions(Rproductions1_h);
    Rproductions_s=Rproductions1_s;
    return Rproductions_s;
  }
  else{
    Rproductions_s=Rproductions_h;
    return Rproductions_s;
  }
}

désolé pour le passage des données de vector en vector, mais il faut que ça corresponde au schéma de traduction dirigée par la syntaxe:
(le "+" est la concaténation)

Code :

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

1
2
Rproductions	→ productions { Rproductions1.h= Rproductions.h + productions.s } Rproductions1 { Rproductions.s = Rproductions1.s }
		→ ε { Rproductions.s = Rproductions.h }

merci pour ton aide

[deedolith]

Toujours les mêmes reproches:
Ton code n'a de sens que pour toi.

Si tu veux faire du C++, Fait du C++.
Pas de la cuisine de camping sous-étoilé comme ce que tu nous montres jusqu'à présent.

[emmesse]

et comme ça?

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
#include <vector>
#include <string>
 
#include "grammaire.hpp"
#include "unilex.hpp"
 
std::vector<std::vector<std::string>> grammaire::resteproductions(std::vector<std::vector<std::string>> const &resteproductions_h){
  if(a.valeur==mot){
    std::vector<std::vector<std::string>>productions_s;
    productions_s=productions();
    std::vector<std::vector<std::string>>resteproductions1_h;
    resteproductions1_h=resteproductions_h;
    resteproductions1_h.insert(resteproductions1_h.end(),productions_s.begin(),productions_s.end());
    std::vector<std::vector<std::string>>resteproductions1_s;
    resteproductions1_s=resteproductions(resteproductions1_h);
    std::vector<std::vector<std::string>>resteproductions_s;
    resteproductions_s=resteproductions1_s;
    return resteproductions_s;
  }
  else{
    std::vector<std::vector<std::string>>resteproductions_s;
    resteproductions_s=resteproductions_h;
    return resteproductions_s;
  }
}

peut-être qu'il faut savoir ça pour comprendre:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
grammaire	→ productions { Rproductions.h = productions.s} Rproductions fin { grammaire.s = Rproductions.s*; grammaire.axiome=grammaire.s[0][0] }
fin	→ fdf | linefeed | ε
Rproductions	→ productions { Rproductions1.h= Rproductions.h + productions.s } Rproductions1 { Rproductions.s = Rproductions1.s }
		→ ε { Rproductions.s = Rproductions.h }
productions	→ mot { ensembleprods.tete = mot.s } fleche ensembleprods linefeed { productions.s = ensembleprods.s }
ensembleprods	→ {production.tete = ensembleprods.tete } production { Rprod.h ||= production.s*; Rprod.tete = ensembleprods .tete } Rprod { ensembleprods.s = Rprod.s }
Rprod	→ barre { production.tete = Rprod.tete } production { Rprod1.h = Rprod.h || production.s*; Rprod1.tete = Rprod.tete } Rprod1 { Rprod.s = Rprod1.s }
	→ ε { Rprod.s = Rprod.h }
production	→ mot { restecorps.h ||= mot.s } restecorps { production.s ||= production.tete*; production.s += restecorps.s }
restecorps	→ mot { restecorps1.h = retecorps.h || mot.s } restecorps1 { restecoprs.s = restecorps1.s }
		→ ε { restecorps.s = restecorps.h }

sinon, dis-moi où exactement tu ne comprends pas...

[deedolith]

C'est pas mieux,
productions, Rproduction, productions.h, productions.s ect ....
Au premier cout d'ôeil, on est supposé comprendre ce que ca veux dire.
Force est de constater que ce n'est pas le cas.

Je suppose que cette question est relative à ta questions précédente:
https://www.developpez.net/forums/d2...semble-indice/
Tu n'as pas l'air d'avoir pris en compte mes remarques.µ
Quelles sont les classes que tu as mis en place ? (leur déclaration suffira pour l'instant).

[emmesse]

Je suppose que cette question est relative à ta questions précédente:

pas du tout, cette discussion est que je n'avais pas compilé le source du programme que je déboggais


quand on lit une grammaire non contextuelle, par exemple, une liste de "X" séparés par des "sep":

Code :

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

1
2
3
A -> X { B.h = X.s } B { A.s = B.s }
B -> sep X { B1.h = f( B.h , X.s }} B1 { B.s = B1.s }
B -> epsilon { B.s = B.h}

la méthode récursive prédictive consiste:
1) A et B sont des non terminaux, donc des fonctions. Lorsqu'ils sont rencontré, on a un appel de fonction.
2) X et sep sont des terminaux. Lors qu'il sont rencontrés, on appelle la fonction "consommer"
3) B.h est un attribut hérité. On le retrouvera en paramètre d'entrée de la fonction B
4) B.s est un attribut synthétisé, c'est le retour de la fonction B

la production A -> X { B.h = X.s } B { A.s = B.s } donne ceci:

Code :

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

1
2
3
4
5
6
7
type_A A(){
   B_h=unitelexicalecourrante;
   consommer(X);
   B_s=B(B_h);
   A_s=B_s;
   return A_s;
}

les productions B s'implémentent comme ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type_B B(type_B_h B_h){
   if(uniteelexicalecourrante==sep){
      consommer(sep);
      X_s=uniteelexicalecourrante;
      consommer(X);
      B1_h = f( B_h , X_s );
      B1_s = B(B1_h);
      B_s = B1_s;
      return B_s;
   }
   else{ //cas epsilon
      B_s = B_h;
      return B_s;
}

ou bien:

Code :

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

1
2
3
4
5
6
7
8
9
10
type_B B(type_B_h B_h){
  while(uiteelexicalecourrante==sep){
    consommer(sep);
    X_s=untieelexicalecourrante;
    consommer(X);
    B_h = f(B_h,X_s)
  }
  B_s=B_h;
  return B_s;
}

on peut aussi fusionner A et B:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
type_A A(){
   B_h=uniteelexicalecourrante;
   consommer(X);
   while(uniteelexicalecourrante==sep){
      consommer(sep);
      X_s=uniteelexicalecourrante;
      consommer(X);
      B_h = f(B_h,X_s);
   }
   B_s=B_h;
   A_s=B_s
   return A_s;
}

C'est la méthode récursive prédictive de la programmations des grammaires.
Mon parseur est un parseur de grammaire. Il y a deux grammaires: celle de l’utilisateur et celle du programme. Ce programme convertit une grammaire non contextuelle en donnée, dans grammaire_s;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
grammaire	→ productions { Rproductions.h = productions.s} Rproductions fin { grammaire.s = Rproductions.s;  }
fin	→ fdf | linefeed | ε
Rproductions	→ productions { Rproductions1.h= Rproductions.h + productions.s } Rproductions1 { Rproductions.s = Rproductions1.s }
		→ ε { Rproductions.s = Rproductions.h }
productions	→ mot { ensembleprods.tete = mot.s } fleche ensembleprods linefeed { productions.s = ensembleprods.s }
ensembleprods	→ {production.tete = ensembleprods.tete } production { Rprod.h ||= production.s; Rprod.tete = ensembleprods .tete } Rprod { ensembleprods.s = Rprod.s }
Rprod	→ barre { production.tete = Rprod.tete } production { Rprod1.h = Rprod.h || production.s; Rprod1.tete = Rprod.tete } Rprod1 { Rprod.s = Rprod1.s }
	→ ε { Rprod.s = Rprod.h }
production	→ mot { restecorps.h ||= mot.s } restecorps { production.s ||= production.tete; production.s += restecorps.s }
restecorps	→ mot { restecorps1.h = retecorps.h || mot.s } restecorps1 { restecoprs.s = restecorps1.s }
		→ ε { restecorps.s = restecorps.h }

[emmesse]

je me suis un peu gourré dans le post précédent, j'aurais dû écrire plutôt ça:

Code :

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

1
2
3
A -> X { B.h = X.s } B { A.s = B.s }
B -> sep X { B1.h = f( B.h , X.s }} B1 { B.s = B1.s }
B -> epsilon { B.s = B.h }

la méthode récursive prédictive consiste:
1) le corps de la production est sélectionné par l'unité lexicale courante
2) A et B sont des non terminaux, donc des fonctions. Lorsqu'ils sont rencontré, on a un appel de fonction.
3) X et sep sont des terminaux. Lors qu'il sont rencontrés, on appelle la fonction "consommer"
4) B.h est un attribut hérité. On le retrouvera en paramètre d'entrée de la fonction B
5) B.s est un attribut synthétisé, c'est le retour de la fonction B

la production A -> X { B.h = X.s } B { A.s = B.s } donne ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type_A A(){
   if(unitelexicalecourrante==X){
      X_s=unitelexicalecourrante;
      B_h=X_s;
      consommer(X);
      B_s=B(B_h);
      A_s=B_s;
   }
   else{
      //message d'erreur
      exit(1);
   }
   return A_s;
}

les productions B s'implémentent comme ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
type_B B(type_B B_h){
   if(unitelexicalecourrante==sep){
      consommer(sep);
      X_s=unitelexicalecourrante;
      consommer(X);
      B1_h = f( B_h , X_s );
      B1_s = B(B1_h);
      B_s = B1_s;
   }
   else //cas epsilon
      B_s = B_h;
   return B_s;
}

ou bien:

Code :

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

1
2
3
4
5
6
7
8
9
10
type_B B(type_B B_h){
  while(unitelexicalecourrante==sep){
    consommer(sep);
    X_s=untielexicalecourrante;
    consommer(X);
    B_h = f(B_h,X_s)
  }
  B_s=B_h;
  return B_s;
}

on peut aussi fusionner A et B:

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
type_A A(){
   if(unitelexicalecourrante==X){
      X_s = unitelexicalecourrante;
      B_h = X_s
      consommer(X);
      while(unitelexicalecourrante==sep){
         consommer(sep);
         X_s=unitelexicalecourrante;
         consommer(X);
         B_h = f(B_h,X_s);
      }
   }
   else{
      //message d'erreur
      exit(1);
   }
   B_s=B_h;
   A_s=B_s
   return A_s;
}

[koala01]

Salut,

Le monsieur te demande de nous montrer le code de la définition des classes que tu as mise en place pour manipuler la grammaire...

Autrement dit, nous aimerions avoir le code de tout ce qui ressemble peu ou prou à

Code :

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

1
2
3
class Quelque chose{
    tout ce qu'il y a ici
};

Et au risque de répéter ce qui a déjà été dit: il est très probable que ton code semble parfaitement compréhensible pour toi, car tu l'as écrit, mais il faut bien te dire que nous, nous ne sommes pas devins, et que nous n'étions pas à coté de toi lorsque tu l'as écrit.
La seule solution pour que nous puissions comprendre ton code -- sans passer des heures à analyser ton code, s'entend -- est donc de faire en sorte que ton code donne toutes les informations sur:

1. ce à quoi servent les différentes classes que tu crées
2. la raison d'être des données que tu déclares: ce à quoi elles sont destinées à servir
3. le but recherché par les différentes fonctions, le résultat auquel on peut s'attendre à partir d'une situation donnée.

On commence tout doucement à comprendre ton code lorsqu'on lit, par exemple des termes comme unitelexicalecourrante ou comme consommer

Par contre, on n'a absolument aucune idée de ce à quoi peuvent servir des données comme B_h, X_s, X, B_s ou A_s : Que sont elles censées représenter à quoi sont elles censées servir
Si tu veux que l'on puisse t'aider, et, surtout, si tu veux éviter de perdre des heures à t'arracher les cheveux dans trois mois lorsque tu reliras ton code, il faut vraiment que tu t'arrange pour trouver des noms "explicites" à ces données, des noms qui ne laisseront planer aucun doute sur la raison d'être, sur l'usage qui sera fait de ces données.

[emmesse]

je précise que la discussion est résolue. Le problème était que je ne déboguais pas le fichier éxecutable voulu.

grammaire hors contexte d'une liste de "elem" séparés par des "sep"
les terminaux sont "elem" et "sep"
les non terminaux sont "liste" et "resteliste"

Code :

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

1
2
3
liste -> elem resteliste
resteliste -> sep elem resteliste
resteliste -> epsilon

epsilon est la production vide
le schéma de traduction dirigé par la syntaxe est:

Code :

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

1
2
3
liste -> elem { resteliste.hérité = elem.attribut } resteliste { liste.synthétisé = resteliste.synthétisé }
resteliste -> sep elem { resteliste1.hérité = elem.attribut } resteliste1 { resteliste.synthétisé = resteliste1.synthétisé }
resteliste -> epsilon { resteliste.synthétisé = resteiste.hérité }

voici l'implémentation de la plupart du programme:

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
enum terminal {elem,sep,fin};//fin=fin de fichier détecté par l'analyseur lexical.
 
struct unitelexicale{//j'ai choisi struct pour l'encapsulement "public" par défaut
  terminal valeur;
  std::string attribut;
};
 
class lexical{
public:
  unitelexicale analyselexicale(); //produit l'unité lexicale suivante
  ...
};
 
class grammaire{
public:
  std::string analysesyntaxique();
  std::string liste(); //axiome de la grammaire, pas d'attributs hérités (pas de paramètres)
  //nous allons fusionner liste() et resteliste(std::string resteliste_herite), que je n'ai pas mentionné ici
  void consommer(terminal terminalcourant);
  std::string fonctionquelquonque(std::string resteliste_herite,std::string unitelexicaleelem);
private:
  lexical L;
  unitelexicale unitelexicalecourante;
};
 
 
std::string grammaire::analysesyntaxique(){
  unitelexicalecourante = L.analyselexicale();
  return liste();
}
 
std::string grammaire::liste(){
  std::string resteliste_herite; //on en a aussi besoin hors du if
  if(unitelexicalecourante.valeur == elem){
    resteliste_herite = unitelexicalecourante.attribut;
    consommer(elem);
    while(unitelexicalecourante.valeur == sep){
      consommer(sep);
      std::string unitelexicaleelem = unitelexicalecourante.attribut; //sauvegarde de l'unité lexicale "elem"
      consommer(elem);
         resteliste_herite = fonctionquelquonque(resteliste_herite,unitelexicaleelem);
      }
   }
   else{
      //message d'erreur
      exit(1);
   }
   std::string resteliste_synthetise = resteliste_herite;
   std::string liste_synthetise = resteliste_synthetise;
   return liste_synthetise;
}
 
void grammaire::consommer(terminal terminalcourant){
  if(unitelexicalecourante.valeur == terminalcourant)
    unitelexicalecourante = L.analyselexicale(); //prochaine unité lexicale
  else
    //message d'ereur
    exit(2);
}
 
std::string grammaire::fonctionquelquonque(std::string resteliste_herite,std::string unitelexicaleelem){
  return resteliste_herite + " " + unitelexicaleelem;
}

[emmesse]

je me cite:

la méthode récursive prédictive consiste:
1) le corps de la production est sélectionné par l'unité lexicale courante
2) A et B sont des non terminaux, donc des fonctions. Lorsqu'ils sont rencontré, on a un appel de fonction.
3) X et sep sont des terminaux. Lors qu'il sont rencontrés, on appelle la fonction "consommer"
4) B.h est un attribut hérité. On le retrouvera en paramètre d'entrée de la fonction B
5) B.s est un attribut synthétisé, c'est le retour de la fonction B

il s'agit du cas un peu général

[deedolith]

Sinon,
Tu penses faire du C++ correcte et intelligible un de ces jours ?

[emmesse]

n'ai-je pas fait un effort au post #11?

[bacelar]

les "exit", comment dire.

[emmesse]

les "exit", comment dire.

tu propose quoi?

[bacelar]

Si c'est des erreurs "environnementale" (donc pas d'erreurs de programmation), exceptionnelles, bin les exceptions sont faites pour ça.

[emmesse]

ok, je vais potasser tout ça.
si j'ai un problème, j'en parlerais dans une nouvelle discussion (je ferai de mon mieux pour écrire du code intelligible)