[BOOST.Spirit] Absence génante

Invité2 · 05/10/2008, 15h02

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** · 06/10/2008, 02h07

Salut,

Qu'est ce que le type Parser, exactement ?

**Alp** · 06/10/2008, 09h46

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 · 06/10/2008, 14h17

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** · 06/10/2008, 14h32

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 · 06/10/2008, 17h54

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;
 
};

[BOOST.Spirit] Absence génante

Boost C++

Vue hybride

Discussions similaires

Partager

Partager