Discussion :

[Trademark]

Bonjour,

J'essaye de réaliser un parser de multiple affectation. Un exemple vaut mieux que mille mots :

Code :

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

1
2
3
4
5
6
// affectation "normal"
key1 = value1
key2 = value2
 
// multiple affectation
key1, key2 = value1, value2

Sachant qu'on les contraintes suivantes :

If there are extra keys, they will be set to an empty value. If there are extra values the last key will be set to the comma-separated list of all remaining values.

Vu qu'un parser est récursif j'ai vraiment des difficultés à parser et stocker cette écriture.

Je dois pouvoir la stocker dans

Code :

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

1
2
3
4
5
6
7
struct attribute
{
  std::string key;
  std::string value;
};
 
typedef std::vector<attribute> all_attribute;

J'ai retourner le problème dans tout les sens pour arriver à la stocker la dedans mais je ne suis pas arriver.

Première Question : Comment faire avec Boost.Spirit (ou alors n'hésitez à mettre une pseudo-grammaire en EBNF) ?

Par conséquent, j'ai créé une structure spécifique pour les multi assignement attribute comme ceci :

Code :

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

1
2
3
4
5
struct multi_attribute
{
  std::vector<std::string> keys;
  std::vector<std::string> values;
};

Comme ça je rempli l'un puis l'autre... Voici mon parser :

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
using qi::lit;
using qi::lexeme;
using qi::eol;
using qi::eoi;
using ascii::char_;
using ascii::string;
using ascii::space;
using namespace qi::labels;
 
using phoenix::at_c;
using phoenix::push_back;
using phoenix::if_;
using phoenix::back;
using phoenix::size;
 
string_rule = *lit('"') >> lexeme[+(char_("a-zA-Z0-9") | char_('.'))[_val += _1]] >> *lit('"');
 
key %= string_rule;
value %= string_rule;
 
multiattribute =
     key[push_back(at_c<0>(_val), _1)] % ','
  >> '='
  >> value[if_(size(at_c<0>(_val)) > size(at_c<1>(_val)))
            [
              push_back(at_c<1>(_val), _1)
            ]
            .else_
            [
              back(at_c<1>(_val)) += ',' + _1
            ]
          ]
     % ','
  >> *eol
;

Ne vous étonnez pas des règles key et value qui ne servent à rien pour le moment, elles me serviront plus tard

Et voici mon test case :

Code :

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

1
2
3
4
5
6
7
[multiattributetests]
  key1, key2 = 1, no  // OK
  key1, key2, key3 = 1, value1  // OK
  key1,         key2 = value1    ,   value2  , value3  // OK
  key1 = value1  // OK
  key1 = 1, 2 , 3  // KO
[/multiattributetests]

En effet, lorsqu'il n'y a qu'une left value et plusieurs right values j'ai une erreur de parsing...

Je ne comprend absolument pas pourquoi.

Deuxième question : Pourquoi ?

Merci d'avance.

[Arzar]

Désolé, mais pour ma part, quand on en vient à Spirit sans un exemple complet, minimale et compilable reproduisant le problème, je ne regarde même pas. La programmation avec Spirit est délicate et beaucoup de choses peuvent mal tourner, du coup tenter de deviner l'origine d'un problème sur des bouts de code épars est souvent vain.

[Trademark]

Je comprend tout à fait, et si j'avais eu ce réflexe, j'aurais remarqué que mon parseur marchait et que le problème ne venait pas de là...

Avant d'exposer mes questions, voici le code source compilable :

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
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_char_class.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
 
#include <boost/spirit/home/phoenix/statement.hpp>
 
#include <string>
#include <vector>
#include <iostream>
 
namespace wml{
namespace ast
{
    struct multi_attribute
    {
      std::vector<std::string> keys;
      std::vector<std::string> values;
    };
}}
 
BOOST_FUSION_ADAPT_STRUCT(
  wml::ast::multi_attribute,
  (std::vector<std::string>, keys)
  (std::vector<std::string>, values)
)
 
namespace wml {
namespace grammar {
    namespace phoenix = boost::phoenix;
    namespace qi = boost::spirit::qi;
    namespace ascii = boost::spirit::ascii;
 
    template <typename Iterator>
    struct multi_attribute : qi::grammar<Iterator, ast::multi_attribute(), qi::locals<std::string>, ascii::space_type>
    {
        multi_attribute() : multi_attribute::base_type(multi_attribute_rule, "multi attribute")
        {
            using qi::lit;
            using ascii::char_;
            using qi::lexeme;
            using qi::eol;
            using qi::eoi;
            using namespace qi::labels;
 
            using phoenix::construct;
            using phoenix::val;
            using phoenix::at_c;
            using phoenix::push_back;
            using phoenix::if_;
            using phoenix::back;
            using phoenix::size;
 
            string_rule = lexeme[+(char_("a-zA-Z0-9") | char_('.'))[_val += _1]];
 
            key %= string_rule;
            value %= string_rule;
 
            multi_attribute_rule =
                 key[push_back(at_c<0>(_val), _1)] % ','
              > '='
              > value[if_(size(at_c<0>(_val)) > size(at_c<1>(_val)))
                        [
                          push_back(at_c<1>(_val), _1)
                        ]
                        .else_
                        [
                          back(at_c<1>(_val)) += ',' + _1
                        ]
                      ]
                 % ','
              > (eol | eoi)
            ; 
 
          multi_attribute_rule.name("multi attribute");
 
          qi::on_error<qi::fail>
          (
            multi_attribute_rule,
            std::cout
              << val("Error! Expecting ")
              << _4                               // what failed?
              << val(" here: \"")
              << construct<std::string>(_3, _2)   // iterators to error-pos, end
              << val("\"")
              << std::endl
          );
        }
 
        qi::rule<Iterator, ast::multi_attribute(), qi::locals<std::string>, ascii::space_type> multi_attribute_rule;
 
        qi::rule<Iterator, std::string(), ascii::space_type> key;
        qi::rule<Iterator, std::string(), ascii::space_type> value;
        qi::rule<Iterator, std::string(), ascii::space_type> string_rule;
    };
}
 
namespace printer
{
  struct multi_attribute
  {
    multi_attribute(){}
 
    void operator()(const ast::multi_attribute& attr)
    {
      std::cout << "key:\n";
      for(const std::string& key : attr.keys)
        std::cout << key << std::endl;
      std::cout << "value:\n";
      for(const std::string& value : attr.values)
       std::cout << value << std::endl; 
    }
  };
}}
 
template <typename grammar, typename ast>
struct wml_test
{
  wml_test(){}
 
  void operator()(const std::string& value)
  {
    ast wml_tree;
    grammar wml;
 
    using boost::spirit::ascii::space;
    using namespace boost::spirit::qi;
 
    std::string::const_iterator iter = value.begin();
    std::string::const_iterator end = value.end();
    bool r = phrase_parse(iter, end, wml, space, wml_tree);
    if (r && iter == end)
    {
        std::cout << "ok" << std::endl;
        wml::printer::multi_attribute()(wml_tree);
    }
    else
    {
        std::string::const_iterator some = iter+2;
        std::string context(iter, (some>end)?end:some);
        std::cout << "ko\n";
        std::cout << "stopped at: \": " << context << "...\"\n";
    }
  }
};
 
int main(int argc, char **argv)
{
    typedef wml::grammar::multi_attribute<std::string::const_iterator> grammar;
 
    wml_test<grammar, wml::ast::multi_attribute> test;
 
    test("key=value\n");
    test("key = value\n");
    test("key1, key2 = value1, value2\n");
    test("key1 = value1, value2\n");
    test("key1, key2 = value1\n");
    test("key1 , key2    ,   key3 = value1  , value2");
    test("key1 , key2 = value1  , value2,    value3  ,  value4");
    return 0;
}

Compilé avec

g++ parser.cpp -std=c++0x

Comme vous le voyez, la structure contient deux vector, comme faire pour avoir un parser qui parse dans une structure comme ça :

Code :

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

1
2
3
4
5
6
7
struct attribute
{
  std::string key;
  std::string value;
}
 
typedef std::vector<attribute> attributes;

Est-ce que c'est seulement possible ? Le but étant d'avoir un AST simplifié (car les multiples attributs ne représenteraient pas un noeud différent dans l'AST) même si le parser, lui, est un peu plus compliqué...


Ensuite, même avec ma méthode actuelle, je ne sais pas comment faire pour les cas où ça débordent d'un côté ou de l'autre du '='. Je re-cite :

If there are extra keys, they will be set to an empty value. If there are extra values the last key will be set to the comma-separated list of all remaining values.

J'ai envie de faire des boucles, des if, et compter ! Bref, j'ai du mal à m'adapter pour écrire du code compatible.

Bien entendu, je ne demande pas à ce que vous m'écriviez le parser, mais si vous avez des pistes de réponses, n'hésitez pas

Merci d'avance.

[Flob90]

Bonsoir,

Je vois difficilement comment on pourrait t'aider plus sans te le faire ! Le code que tu as déjà utilise tout les éléments que tu as besoin (entre autre : BOOST_FUSION_ADAPT_STRUCT, at_c, push_back et back). La différence c'est qu'il fait le travail sous une autre forme (dans le code ca revient "presque" à inverser les at_c et les push_back).

[Arzar]

Ben à vrai dire j'ai fait l'exercice et la deuxième forme m'a l'air beaucoup plus dure à mettre en œuvre que la première
Je n'ai pas trouvé de manière élégante n'impliquant pas l’utilisation de variables locales (qi::locals). C'est peut être cette notion qui te manquait Trademark ? Il est facile de la rater car elle n'est presque jamais mentionnée dans la doc....

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
 
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/home/phoenix/statement.hpp>
 
#include <string>
#include <vector>
#include <iostream>
 
namespace wml{
namespace ast
{
   struct attribute
   {
      attribute(const std::string& key, const std::string& value):key(key), value(value){}
      attribute(const std::string& key):key(key){}
      std::string key;
      std::string value;
   };
 
   typedef std::vector<attribute> multi_attribute;
 
}}
 
 
namespace wml {
namespace grammar {
   namespace phoenix = boost::phoenix;
   namespace qi = boost::spirit::qi;
   namespace ascii = boost::spirit::ascii;
 
   template <typename Iterator>
   struct multi_attribute : qi::grammar<Iterator, ast::multi_attribute(), qi::locals<int>, ascii::space_type>
   {
      multi_attribute() : multi_attribute::base_type(multi_attribute_rule, "multi attribute")
      {
          using ascii::char_;
          using qi::lexeme;
          using qi::eol;
          using qi::eoi;
	  using qi::eps;
          using namespace qi::labels;
 
	  using phoenix::bind;
	  using phoenix::ref;
          using phoenix::construct;
          using phoenix::val;
	  using phoenix::at;
          using phoenix::push_back;
          using phoenix::if_;
          using phoenix::back;
          using phoenix::size;
 
          string_rule = lexeme[+(char_("a-zA-Z0-9") | char_('.'))];
 
          key = string_rule;
          value = string_rule;
 
	  multi_attribute_rule =
	      eps[_a = 0] // utilisation du parser eps qui réussit toujours pour initialiser la variable locale _a
	   > key[push_back(_val, construct<ast::attribute>(_1))] % ',' // constructeur ast::attribute(const std::string& key)
	   > '='
	   // le texte est parsé de gauche à droite donc à ce stade le std::vector<attribute> _val possède déjà sa taille finale (nombre de clé)
	   > value[if_( _a < size(_val)) 
	      [
	         phoenix::bind(&ast::attribute::value, at(_val, _a)) = _1,
		 _a++
	      ]
	      .else_
	      [
	         phoenix::bind(&ast::attribute::value, back(_val)) += ',' + _1
	      ]
	   ]
	   % ','
          > (eol | eoi)
          ; 
 
      multi_attribute_rule.name("multi attribute");
 
      qi::on_error<qi::fail>
      (
         multi_attribute_rule,
         std::cout
         << val("Error! Expecting ")
         << _4                               // what failed?
         << val(" here: \"")
         << construct<std::string>(_3, _2)   // iterators to error-pos, end
         << val("\"")
         << std::endl
      );
    }
 
    qi::rule<Iterator, ast::multi_attribute(), qi::locals<int>,  ascii::space_type> multi_attribute_rule;
 
    qi::rule<Iterator, std::string(), ascii::space_type> key;
    qi::rule<Iterator, std::string(), ascii::space_type> value;
    qi::rule<Iterator, std::string(), ascii::space_type> string_rule;
    };
}
 
namespace printer
{
  struct multi_attribute
  {
    multi_attribute(){}
 
    void operator()(const ast::multi_attribute& multi_attr)
    {
       for(const wml::ast::attribute& attr : multi_attr)
	{
	   std::cout << attr.key << ":" << attr.value << "\n";
	}
    }
  };
}}
 
template <typename grammar, typename ast>
struct wml_test
{
  wml_test(){}
 
  void operator()(const std::string& value)
  {
    ast wml_tree;
    grammar wml;
 
    using boost::spirit::ascii::space;
    using namespace boost::spirit::qi;
 
    std::string::const_iterator iter = value.begin();
    std::string::const_iterator end = value.end();
    bool r = phrase_parse(iter, end, wml, space, wml_tree);
    if (r && iter == end)
    {
        std::cout << "ok" << std::endl;
        wml::printer::multi_attribute()(wml_tree);
    }
    else
    {
        std::string::const_iterator some = iter+2;
        std::string context(iter, (some>end)?end:some);
        std::cout << "ko\n";
        std::cout << "stopped at: \": " << context << "...\"\n";
    }
  }
};
 
int main(int argc, char **argv)
{
    typedef wml::grammar::multi_attribute<std::string::const_iterator> grammar;
 
    wml_test<grammar, wml::ast::multi_attribute> test;
 
    test("key=value\n");
    test("key = value\n");
    test("key1, key2 = value1, value2\n");
	test("key1, key2, key3, key4 = value1, value2, value3, value4\n");
    test("key1 = value1, value2\n");
    test("key1, key2 = value1\n");
    test("key1 , key2    ,   key3 = value1  , value2");
    test("key1 , key2 = value1  , value2,    value3  ,  value4");
    return 0;
}

Note : J'ai eu quelques soucis de compilation avec les at_c, du coup j'ai laissé tombé BOOST_FUSION_ADAPT_STRUCT pour revenir à des phoenix::bind.

[Trademark]

Merci pour vos réponses, c'est vrai que je n'avais pas saisi comment on pouvait se servir des variables locales.

Ceci résout la première partie de mon problème, néanmoins, je sens qu'il me manque encore une notion.

En effet, comment peut t-on changer de parseur « à la volée », c'est-à-dire sur une condition ? Car dans :

Code :

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

1
2
3
4
.else_
[
  phoenix::bind(&ast::attribute::value, back(_val)) += ',' + _1
]

Les espaces sont enlevés alors qu'on aimerait les garder… À ce moment, d'une manière ou d'une autre, il faudrait switcher le parser.