Discussion :

[Invité2]

Bonjour à toutes à tous,

Ca va bientôt faire 3 mois que je suis sur BOOST.Spirit, bien que ma compréhension soit relative, faudrait traduire cette doc !, je me heurte à un problème d'anvergure : boost::spirit::parse à disparut :

||=== MyParsers, Debug ===|
\main.cpp||In function `int main(int, char**)'
\main.cpp|71|error: no matching function for call to `parse(char*&, Parser*&, const boost::spirit::space_parser&)'|
\KolorEngine\main.cpp|70|warning: unused variable 'info'|
||=== Build finished: 1 errors, 1 warnings ===|

Code :

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

1
2
3
4
        Parser* Parseur = fabrique.Apppel(argv[1]); // Ligne 68
 
        boost::spirit::parse_info<> info =
        boost::spirit::parse(argv[2], Parseur, boost::spirit::space_p);

Bon

J'ai réinstallé la bibliothèque partiellement (juste boost.spirit) et globalement (tout boost) une dizaine de fois chacun...
J'ai également bien pensé à inclure ça :

Code :

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

#include <boost/spirit.hpp>

Quelqu'un aurait une explication ?

Par avance merci de votre aide

[Florian Goo]

Salut,

Qu'est ce que le type Parser, exactement ?

[Alp]

N'est-ce pas un problème de prototype de fonction ? Tu lui passes un argument qui ne lui convient pas, ou quoi.

Je ne connais pas des masses Spirit, mais le compilateur ne te propose pas des candidats pour boost::spirit::parse ?

[Invité2]

Pour BOOST.Spirit, je me suis appuyé sur la doc :
http://spirit.sourceforge.net/distri...ick_start.html

Pour le parseur, il est modeste, inspiré d'un exemple, mais en théorie faux :

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
    // Le parseur
    template <typename ScannerT>
    struct definition
    {
        definition(CPP const& self)
        {
            program
                =  *boost::spirit::space_p >>
                    *(   preprocessor                   [self.preprocessor]
                    |   comment                         [self.comment]
                    |   keyword                         [self.keyword]
                    |   identifier                      [self.identifier]
                    |   special                         [self.special]
                    |   string                          [self.string]
                    |   literal                         [self.literal]
                    |   number                          [self.number]
                    |   boost::spirit::anychar_p        [self.unexpected]
                    |   type                            [self.type]
                    |   condition                       [self.condition]
                    |   boucle                          [self.boucle]
                    |   type                            [self.type]
                    |   objet                           [self.objet]
                    )
                ;
 
            preprocessor
                =   '#' >> *boost::spirit::space_p >> identifier
                ;
 
            comment
                =   +((boost::spirit::comment_p("//") | boost::spirit::comment_p("/*", "*/"))
                    >> *boost::spirit::space_p)
                ;
 
            keyword
                =   keywords >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            keywords
                =   "and_eq", "and", "asm", "auto", "bitand", "bitor",
                    "catch", "compl", "default", "enum", "export", "false",
                    "inline", "mutable", "namespace", "not_eq", "not",
                    "or_eq", "or", "register", "reinterpret_cast", "return",
                    "sizeof", "template", "true", "try", "typedef", "typeid",
                    "typename", "union", "unsigned", "using", "volatile", "xor_eq", "xor"
                ;
 
            condition
                =   conditions >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            conditions
                =   "if", "else", "elseif", "case", "switch"
                ;
 
            boucle
                =   boucles >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            boucles
                =   "while", "for", "break", "continue", "goto", "do"
                ;
 
            objet
                =   objets >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            objets
                =   "class", "struct", "private", "protected", "public", "throw", "this",
                    "new", "delete", "friend", "operator", "explicit"
                ;
 
            type
                =   types >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            types
                =   "bool", "int", "signed", "unsigned", "char", "double", "long", "short",
                    "static", "virtual", "void", "wchart", "float", "static_cast", "dynamic_cast",
                    "const_cast", "const", "extern"
                ;
 
            special
                =   +boost::spirit::chset_p("~!%^&*()+={[}]:;,<.>?/|\\-") >> *boost::spirit::space_p
                ;
 
            string
                =   !boost::spirit::as_lower_d['l'] >> boost::spirit::confix_p('"', *boost::spirit::c_escape_ch_p, '"')
                    >> *boost::spirit::space_p
                ;
 
            literal
                =   !boost::spirit::as_lower_d['l'] >> boost::spirit::confix_p('\'', *boost::spirit::c_escape_ch_p, '\'')
                    >> *boost::spirit::space_p
                ;
 
            number
                =   (   boost::spirit::real_p
                    |   boost::spirit::as_lower_d["0x"] >> boost::spirit::hex_p
                    |   '0' >> boost::spirit::oct_p
                    )
                    >>  *boost::spirit::as_lower_d[boost::spirit::chset_p("ldfu")]
                    >>  *boost::spirit::space_p
                ;
 
            identifier
                =   ((boost::spirit::alpha_p | '_') >> *(boost::spirit::alnum_p | '_'))
                    >> *boost::spirit::space_p
                ;
        }
 
        boost::spirit::symbols<>
            keywords, types, conditions, boucles, objets;
 
        boost::spirit::rule<ScannerT>
            program, preprocessor, comment, special, string, literal,
            number, identifier, keyword, type, condition, boucle, objet;
 
        boost::spirit::rule<ScannerT> const&
        start() const
        {
            return program;
        }
    };

Exemple : http://spirit.sourceforge.net/reposi...pp_to_html.zip

Voilà, je suis actuellement sur la doc, faudrait d'ailleur que je la traduise...

[Florian Goo]

Ce que tu nous montres semble plutôt être une grammaire.

Peux-tu nous montrer le code ENTIER de ta classe Parser ? Je la soupçonne très fortement de ne pas dériver de boost::spirit::grammar :

Code :

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

1
2
3
4
5
6
7
8
9
10
    struct my_grammar : public grammar<my_grammar>
    {
        template <typename ScannerT>
        struct definition
        {
            rule<ScannerT>  r;
            definition(my_grammar const& self)  { r = /*..define here..*/; }
            rule<ScannerT> const& start() const { return r; }
        };
    };

http://www.boost.org/doc/libs/1_36_0...c/grammar.html

[Invité2]

Je suis infiniment désolé, un oublis :

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
 
// Classe-interface des parseurs
class Parser : public boost::spirit::grammar<Parser> {
    public:
 
    virtual ~Parser(void);
 
    virtual Parser* Clone() = 0;
 
    bool existe;
 
    private:
 
    std::string dernier;
 
};
 
class CPP : public Parser{
    public:
 
    CPP();
 
    Parser* Clone();
 
    ~CPP(void);
 
    bool existe;
 
    // Le parseur
    template <typename ScannerT>
    struct definition
    {
        definition(CPP const& self)
        {
            program
                =  *boost::spirit::space_p >>
                    *(   preprocessor                   [self.preprocessor]
                    |   comment                         [self.comment]
                    |   keyword                         [self.keyword]
                    |   identifier                      [self.identifier]
                    |   special                         [self.special]
                    |   string                          [self.string]
                    |   literal                         [self.literal]
                    |   number                          [self.number]
                    |   boost::spirit::anychar_p        [self.unexpected]
                    |   type                            [self.type]
                    |   condition                       [self.condition]
                    |   boucle                          [self.boucle]
                    |   type                            [self.type]
                    |   objet                           [self.objet]
                    )
                ;
 
            preprocessor
                =   '#' >> *boost::spirit::space_p >> identifier
                ;
 
            comment
                =   +((boost::spirit::comment_p("//") | boost::spirit::comment_p("/*", "*/"))
                    >> *boost::spirit::space_p)
                ;
 
            keyword
                =   keywords >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            keywords
                =   "and_eq", "and", "asm", "auto", "bitand", "bitor",
                    "catch", "compl", "default", "enum", "export", "false",
                    "inline", "mutable", "namespace", "not_eq", "not",
                    "or_eq", "or", "register", "reinterpret_cast", "return",
                    "sizeof", "template", "true", "try", "typedef", "typeid",
                    "typename", "union", "unsigned", "using", "volatile", "xor_eq", "xor"
                ;
 
            condition
                =   conditions >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            conditions
                =   "if", "else", "elseif", "case", "switch"
                ;
 
            boucle
                =   boucles >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            boucles
                =   "while", "for", "break", "continue", "goto", "do"
                ;
 
            objet
                =   objets >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            objets
                =   "class", "struct", "private", "protected", "public", "throw", "this",
                    "new", "delete", "friend", "operator", "explicit"
                ;
 
            type
                =   types >> (boost::spirit::eps_p - (boost::spirit::alnum_p | '_')) >> *boost::spirit::space_p
                ;   // make sure we recognize whole words only
 
            types
                =   "bool", "int", "signed", "unsigned", "char", "double", "long", "short",
                    "static", "virtual", "void", "wchart", "float", "static_cast", "dynamic_cast",
                    "const_cast", "const", "extern"
                ;
 
            special
                =   +boost::spirit::chset_p("~!%^&*()+={[}]:;,<.>?/|\\-") >> *boost::spirit::space_p
                ;
 
            string
                =   !boost::spirit::as_lower_d['l'] >> boost::spirit::confix_p('"', *boost::spirit::c_escape_ch_p, '"')
                    >> *boost::spirit::space_p
                ;
 
            literal
                =   !boost::spirit::as_lower_d['l'] >> boost::spirit::confix_p('\'', *boost::spirit::c_escape_ch_p, '\'')
                    >> *boost::spirit::space_p
                ;
 
            number
                =   (   boost::spirit::real_p
                    |   boost::spirit::as_lower_d["0x"] >> boost::spirit::hex_p
                    |   '0' >> boost::spirit::oct_p
                    )
                    >>  *boost::spirit::as_lower_d[boost::spirit::chset_p("ldfu")]
                    >>  *boost::spirit::space_p
                ;
 
            identifier
                =   ((boost::spirit::alpha_p | '_') >> *(boost::spirit::alnum_p | '_'))
                    >> *boost::spirit::space_p
                ;
        }
 
        boost::spirit::symbols<>
            keywords, types, conditions, boucles, objets;
 
        boost::spirit::rule<ScannerT>
            program, preprocessor, comment, special, string, literal,
            number, identifier, keyword, type, condition, boucle, objet;
 
        boost::spirit::rule<ScannerT> const&
        start() const
        {
            return program;
        }
    };
 
    afficheur   preprocessor, comment, keyword, identifier,
                special, string, literal, number, type, condition, boucle, objet;
 
    unexpected_char unexpected;
 
    private:
    std::string dernier;
 
};

[Florian Goo]

Ça n'explique pas le message d'erreur, mais déjà, ta classe Parser devrait avoir une classe interne definition.
Même si ta classe CPP (attention, le tout majuscules, par convention, c'est pour les macros !) a bien une telle classe interne, celle-ci ne peut être visible via ton interface Parser.

Par ailleurs, je te conseillerai de ne pas passer par une fabrique (tout du moins dans un premier temps) pour créer ton parser.

[Florian Goo]

Ah, si, désolé… boost::spirit::parse() prend une référence de grammaire et non un pointeur !

Donc, déjà :

Code :

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

1
2
 
boost::spirit::parse(argv[2], *Parseur, boost::spirit::space_p);

Mais mon petit doigt me dit que tu auras une autre erreur te disant que Parser::definition n'existe pas. Si tel est le cas, lis mon précédent message.

[Invité2]

Oui oui, je compte la virer, mais je met quoi dans la classe définition de Parser (hors-mit {})
On m'a toujours dit de bannir les macros, donc, je les touches pas, mais je sais, c'est pas une escuse...

[Florian Goo]

Tu as raté mon dernier message

[Invité2]

Oui, mais tu as raison, j'ai pas le temps je verrais ça demain mais :

||=== KolorEngine, Debug ===|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\impl\grammar.ipp||In function `typename boost::spirit::parser_result<boost::spirit::grammar<DerivedT, ContextT>, ScannerT>::type boost::spirit::impl::grammar_parser_parse(const boost::spirit::grammar<DerivedT, ContextT>*, const ScannerT&) [with int N = 0, DerivedT = Parser, ContextT = boost::spirit::parser_context<boost::spirit::nil_t>, ScannerT = boost::spirit::scanner<const char*, boost::spirit::scanner_policies_t>]'
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\grammar.hpp|57|instantiated from `typename boost::spirit::parser_result<boost::spirit::grammar<DerivedT, ContextT>, ScannerT>::type boost::spirit::grammar<DerivedT, ContextT>::parse_main(const ScannerT&) const [with ScannerT = boost::spirit::scanner<const char*, boost::spirit::scanner_policies_t>, DerivedT = Parser, ContextT = boost::spirit::parser_context<boost::spirit::nil_t>]'|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\grammar.hpp|65|instantiated from `typename boost::spirit::parser_result<boost::spirit::grammar<DerivedT, ContextT>, ScannerT>::type boost::spirit::grammar<DerivedT, ContextT>::parse(const ScannerT&) const [with ScannerT = boost::spirit::scanner<const char*, boost::spirit::scanner_policies_t>, DerivedT = Parser, ContextT = boost::spirit::parser_context<boost::spirit::nil_t>]'|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\scanner\impl\skipper.ipp|133|instantiated from `static boost::spirit::parse_info<IteratorT> boost::spirit::impl::phrase_parser<boost::spirit::space_parser>::parse(const IteratorT&, const IteratorT&, const ParserT&, const boost::spirit::space_parser&) [with IteratorT = const char*, ParserT = Parser]'|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\scanner\impl\skipper.ipp|154|instantiated from `boost::spirit::parse_info<IteratorT> boost::spirit::parse(const IteratorT&, const IteratorT&, const boost::spirit::parser<DerivedT>&, const boost::spirit::parser<SkipT>&) [with IteratorT = const char*, ParserT = Parser, SkipT = boost::spirit::space_parser]'|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\scanner\impl\skipper.ipp|173|instantiated from `boost::spirit::parse_info<const CharT*> boost::spirit::parse(const CharT*, const boost::spirit::parser<DerivedT>&, const boost::spirit::parser<SkipT>&) [with CharT = char, ParserT = Parser, SkipT = boost::spirit::space_parser]'|
|73|instantiated from here|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\impl\grammar.ipp|293|error: no class template named `definition' in `class Parser'|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\impl\grammar.ipp|296|error: no class template named `definition' in `class Parser'|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\impl\grammar.ipp|298|error: no class template named `definition' in `class Parser'|
||=== Build finished: 3 errors, 0 warnings ===|

[Invité2]

En rajoutant la définitions vide, j'obtiens :

C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\impl\grammar.ipp|279|error: 'struct Parser::definition<boost::spirit::scanner<const char*, boost::spirit::scanner_policies_t> >' has no member named 'start'|

Quelqu'un pourrait me dire d'où ça vient, ou tout du moins me dire ce que ça signifie ?

Par avance merci de votre aide

[Florian Goo]

C'est pourtant clair, non ?
Parser::definition n'a pas la fonction membre "start()" que tu es obligé d'implémenter, comme la doc de Spirit l'indique.

Si tu veux continuer à faire en sorte que Parser ne soit qu'une interface (et CPP une implémentation de celle-ci), il faut que tu déclares start() virtuelle pure.

[Invité2]

Hum, oui, mais le message est tronqué donc j'avais du mal à identifier le problème, après quelques bugs malencontreux :

)]+0x11)||undefined reference to `Parser::definition<boost::spirit::scanner<char const*, boost::spirit::scanner_policies<boost::spirit::skipper_iteration_policy<boost::spirit::iteration_policy>, boost::spirit::match_policy, boost::spirit::action_policy> > >::start() const'|

Pourtant j'ai tout fait comme il faut :

Code :

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

1
2
3
4
5
6
7
8
    template <typename ScannerT>
    struct definition
    {
        definition(Parser const& self)
        {
        }
        boost::spirit::rule<ScannerT> const& start() const;
    };

Une dernière idée ?

[Florian Goo]

Undefined reference, c'est une erreur de linking. Ça veut dire que la définition de Parser::definition::start() n'est pas trouvée (tu ne l'as d'ailleurs sûrement pas écrite) par l'éditeur de lien.

Mais étant donné que tu veux que Parser soit une interface et CPP son implémentation, comme je te le disais, il faut que Parser::definition::start() soit virtuelle pure :

Code :

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

1
2
3
4
5
6
7
8
9
 
template <typename ScannerT>
struct definition
{
    definition(Parser const& self)
    {
    }
    virtual boost::spirit::rule<ScannerT> const& start() const = 0;
};

[Invité2]

Mmmmh, je pense ne plus avoir de problème "direct" ce bug vient-il de ma définition ?

C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\impl\grammar.ipp|178|error: cannot allocate an object of type `Parser::definition<boost::spirit::scanner<const char*, boost::spirit::scanner_policies_t> >'|
C:\MinGW\bin\..\lib\gcc\mingw32\3.4.5\..\..\..\..\include\boost\spirit\home\classic\core\non_terminal\impl\grammar.ipp|178|error: because the following virtual functions are abstract
\parser.h|46|error: const boost::spirit::rule<ScannerT, boost::spirit::nil_t, boost::spirit::nil_t>& Parser::definition<ScannerT>::start() const [with ScannerT = boost::spirit::scanner<const char*, boost::spirit::scanner_policies_t>]|

Code :

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

        virtual boost::spirit::rule<ScannerT> const& start() const = 0;// Ligne 46

Par avance merci de votre aide

[Florian Goo]

Si tu obtiens ce message, c'est qu'à un moment dans ton code tu essaies de créer une instance de Parser.

Une fois pour toute : la classe Parser est-elle une interface, oui ou non ?

[Invité2]

Oui, et le seul endrois où j'essay de l'instancier est :

Code :

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

        Parser* Parseur = fabrique.Apppel(argv[1]);

Je suis coincé

Par avance merci de votre aide

[Florian Goo]

Peux-tu coller le code de ta fabrique ?

[Invité2]

La voilà :

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
class Fabrique
{
    std::map<std::string,Parser*> langages;
 
public:
	// Fonction qui associe clé <=> prototype
	void Ajoute(const std::string& clef,Parser* objet);
 
	// Celle qui va créer les objets
	Parser* Apppel(const std::string& clef) const;
};
 
void Fabrique::Ajoute(const std::string& clef, Parser* objet)
{
    //si la clé n'est pas déjà présente
	if(langages.find(clef)==langages.end())
    {
        //on ajoute l'objet dans la map
        langages[clef]=objet;
    }
 
       //on pourrait détruire objet mais cette tâche ne revient pas à Ajoute
}
 
Parser* Fabrique::Apppel(const std::string& clef) const
{
		Parser* tmp=0;
	    std::map<std::string, Parser*>::const_iterator iterateur=langages.find(clef);
 
		//si l'itérateur ne vaut pas map.end(), cela signifie que que la clé à été trouvée
		if(iterateur!=langages.end())
		{
            tmp=((*iterateur).second)->Clone();
      	}
      	else
      	{
      	    tmp=new default_langage;
      	}
 
		//on pourrait lancer une exeption si la clé n'a pas été trouvée
 
		return tmp;
}

C'est grave docteur ?

Par avance merci de votre aide