IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

p[1] != "epsilon"


Sujet :

C++

  1. #1
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut p[1] != "epsilon"
    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
    Nom : ecran.jpg
Affichages : 337
Taille : 60,5 Ko
    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?

  2. #2
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    c'est parce que j'ai compilé comme ça:
    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

  3. #3
    Membre Expert
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    1 507
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 1 507
    Par défaut
    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).

  4. #4
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    @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

  5. #5
    Membre Expert
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    1 507
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 1 507
    Par défaut
    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.

  6. #6
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    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...

  7. #7
    Membre Expert
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    1 507
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 1 507
    Par défaut
    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).

  8. #8
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    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 }

  9. #9
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    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;
    }

  10. #10
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    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.
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  11. #11
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    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;
    }

  12. #12
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    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

  13. #13
    Membre Expert
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    1 507
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 1 507
    Par défaut
    Sinon,
    Tu penses faire du C++ correcte et intelligible un de ces jours ?

  14. #14
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    n'ai-je pas fait un effort au post #11?

  15. #15
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 490
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 490
    Par défaut
    les "exit", comment dire.

  16. #16
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    Citation Envoyé par bacelar Voir le message
    les "exit", comment dire.
    tu propose quoi?

  17. #17
    Expert confirmé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 490
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 490
    Par défaut
    Si c'est des erreurs "environnementale" (donc pas d'erreurs de programmation), exceptionnelles, bin les exceptions sont faites pour ça.

  18. #18
    Membre éclairé

    Homme Profil pro
    développeur à la maison
    Inscrit en
    Septembre 2006
    Messages
    396
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : développeur à la maison

    Informations forums :
    Inscription : Septembre 2006
    Messages : 396
    Billets dans le blog
    16
    Par défaut
    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)

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Quote dans une requete...
    Par Isildur dans le forum Langage SQL
    Réponses: 6
    Dernier message: 20/06/2006, 10h57
  2. [xsl]simuler le mecanisme OO de "liaison dynamique"
    Par philemon_siclone dans le forum XSL/XSLT/XPATH
    Réponses: 10
    Dernier message: 19/12/2003, 11h34
  3. Problème de quote
    Par kennini dans le forum ASP
    Réponses: 4
    Dernier message: 20/11/2003, 09h40
  4. VARCHAR contenant une quote '
    Par tonyskn dans le forum Langage SQL
    Réponses: 2
    Dernier message: 29/05/2003, 19h21
  5. Quotes dans TFilenameEdit (RXLib)
    Par AnnSo dans le forum Composants VCL
    Réponses: 3
    Dernier message: 23/01/2003, 20h26

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo