Spirit + phoenix + closure

**3DArchi** · 07/10/2008, 15h56

Bonjour,
En gros, dans ma grammaire j'ai un premier champs qui me dit le nombre d'éléments qui suivent. Je n'arrive pas à la construire: je n'arrive pas à faire le lien entre le nombre d'éléments lire et un parser repeat_p. J'essaye avec lazy_p mais je ne vois pas du tout comment tourner la chose. L'aide boost m'a été assez peu précieuse alors si quelque a une piste, je suis preneur.
Code:

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
#include <iostream>
#include <boost/spirit.hpp>
#include <boost/spirit/dynamic/lazy.hpp>
using namespace BOOST_SPIRIT_CLASSIC_NS;
using namespace phoenix;
 
struct ma_closure : boost::spirit::closure<ma_closure, size_t>
{
  member1 NbrElts;
};
 
 
class MaGrammaire
   :public grammar<MaGrammaire>
{
public:
   template <typename ScannerT>
   struct definition
   {
      rule<ScannerT,ma_closure::context_t> liste;
      rule<ScannerT> element;
      definition(MaGrammaire const& self)
      {
         liste             = uint_p[assign_a(liste.NbrElts)]>>":">>lazy_p(repeat_p(liste.NbrElts)[element]);  // Comment faire?
         element           = uint_p>>",";
      }
      rule<ScannerT,ma_closure::context_t> const& start() const 
         {return liste;}
   };
};
 
int main()
{
   MaGrammaire MonParseur;
 
   // Create a file iterator for this file
   std::string L_strChaine("5:1,2,3,4,5,");
   parse_info<char const*> info = parse(
        L_strChaine.c_str(),
        L_strChaine.c_str()+L_strChaine.length(),
        MonParseur
    );
    if (info.full)
        std::cout << "Parse succeeded!\n";
    else
        std::cout << "Parse failed!\n";
 
 
 
 
   return std::getc(stdin);
}

**3DArchi** · 08/10/2008, 12h52

Bon, j'ai compris un truc: il faut que penser 'Functional Programming', donc des foncteurs appropriés!
J'ai donc rajouté un foncteur regle_lire_liste pour créer la règle à la volée. J'ai changé comme suit:

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
#include <boost/spirit.hpp>
#include <boost/spirit/dynamic/lazy.hpp>
using namespace BOOST_SPIRIT_CLASSIC_NS;
using namespace phoenix;
 
struct ma_closure : boost::spirit::closure<ma_closure, size_t>
{
  member1 NbrElts;
};
 
class MaGrammaire
   :public grammar<MaGrammaire>
{
public:
   template <typename ScannerT>
   struct definition
   {
      template<typename TArg>
      struct regle_lire_liste
      {
         template<class Tuple>
         struct result
         {
            typedef rule<ScannerT> type;
         };
         explicit
            regle_lire_liste(definition &P_def,TArg& P_arg):m_def(P_def),m_arg(P_arg)
         {
         }
         rule<ScannerT> operator()()const
         {
            return repeat_p<size_t>(m_arg())[m_def.element];
         }
      protected:
         definition &m_def;
         TArg& m_arg;
         rule<ScannerT> m_regle;
      };
      template<class T>
      regle_lire_liste<T> regle_lire_liste_p(definition &P_def, T&P_arg)
      {
         return regle_lire_liste<T>(P_def,P_arg);
      }
      rule<ScannerT,ma_closure::context_t> liste;
      rule<ScannerT> element;
      rule<ScannerT> lire_liste;
 
      definition(MaGrammaire const& self)
      {
         liste             = uint_p[assign_a(liste.NbrElts)]>>":">>lire_liste;
         lire_liste        = lazy_p(regle_lire_liste_p(*this,liste.NbrElts));
         element           = uint_p>>",";
      }
      rule<ScannerT,ma_closure::context_t> const& start() const 
         {return liste;}
   };
};
 
#include <iostream>
int main()
{
   MaGrammaire MonParseur;
 
   // Create a file iterator for this file
   std::string L_strChaine("5:1,2,3,4,5,");
   parse_info<char const*> info = parse(
        L_strChaine.c_str(),
        L_strChaine.c_str()+L_strChaine.length(),
        MonParseur
    );
    if (info.full)
        std::cout << "Parse succeeded!\n";
    else
        std::cout << "Parse failed!\n";
 
 
 
 
   return std::getc(stdin);
}

Le problème maintenant c'est que je n'obtient pas de valeur correcte dans return repeat_p<size_t>(m_arg())[m_def.element]; pour m_arg. Il me renvoie n'importe quoi! Un piste?
Merci d'avance car je sèche un peu!

**3DArchi** · 08/10/2008, 12h59

Ben, fallait pousser le raisonnement jusqu'au bout! Le foncteur liste.NbrElts re définit l'opérateur d'affectation pour retourner un foncteur d'affectation (0-ary) lié entre l'espace de stockage de liste.NbrElts et la valeur extraite de uint_p. Donc, l'affectation à proprement parler n'est pas faite.
Solution (provisoire?):

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
#include <boost/spirit.hpp>
#include <boost/spirit/dynamic/lazy.hpp>
using namespace BOOST_SPIRIT_CLASSIC_NS;
using namespace phoenix;

struct ma_closure : boost::spirit::closure<ma_closure, size_t>
{
  member1 NbrElts;
};

class MaGrammaire
   :public grammar<MaGrammaire>
{
public:
   template <typename ScannerT>
   struct definition
   {
      template<typename TArg>
      struct regle_lire_liste
      {
         template<class Tuple>
         struct result
         {
            typedef rule<ScannerT> type;
         };
         explicit
            regle_lire_liste(definition &P_def,TArg& P_arg):m_def(P_def),m_arg(P_arg)
         {
         }
         rule<ScannerT> operator()()const
         {
            return repeat_p<size_t>(m_arg())[m_def.element];
         }
      protected:
         definition &m_def;
         TArg& m_arg;
         rule<ScannerT> m_regle;
      };
      template<class T>
      regle_lire_liste<T> regle_lire_liste_p(definition &P_def, T&P_arg)
      {
         return regle_lire_liste<T>(P_def,P_arg);
      }
      rule<ScannerT,ma_closure::context_t> liste;
      rule<ScannerT> element;
      rule<ScannerT> lire_liste;

      definition(MaGrammaire const& self)
      {
         liste             = uint_p[liste.NbrElts=arg1]>>":">>lire_liste;
         lire_liste        = lazy_p(regle_lire_liste_p(*this,liste.NbrElts));
         element           = uint_p>>",";
      }
      rule<ScannerT,ma_closure::context_t> const& start() const 
         {return liste;}
   };
};

#include <iostream>
int main()
{
   MaGrammaire MonParseur;

   // Create a file iterator for this file
   std::string L_strChaine("5:1,2,3,4,5,");
   parse_info<char const*> info = parse(
        L_strChaine.c_str(),
        L_strChaine.c_str()+L_strChaine.length(),
        MonParseur
    );
    if (info.full)
        std::cout << "Parse succeeded!\n";
    else
        std::cout << "Parse failed!\n";




   return std::getc(stdin);
}

Spirit + phoenix + closure

Boost C++

Vue hybride

Discussions similaires

Partager

Partager