[BOOST.Spirit] Absence génante

Version imprimable

05/10/2008, 15h02
Invité2

[BOOST.Spirit] Absence génante
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 :

Citation:

||=== 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:

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 :bug:

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:

#include <boost/spirit.hpp>

Quelqu'un aurait une explication ?

Par avance merci de votre aide
06/10/2008, 02h07
Florian Goo

Salut,

Qu'est ce que le type Parser, exactement ?
06/10/2008, 09h46
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 ?

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:

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...

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:

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

Je suis infiniment désolé, un oublis :

Code:

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

06/10/2008, 19h08
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.
06/10/2008, 19h12
Florian Goo
Ah, si, désolé… boost::spirit::parse() prend une référence de grammaire et non un pointeur !

Donc, déjà :
Code:

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.
06/10/2008, 19h12
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...
06/10/2008, 19h19
Florian Goo

Tu as raté mon dernier message :)
06/10/2008, 20h45
Invité2

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

Citation:

||=== 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 ===|
07/10/2008, 12h29
Invité2

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

Citation:

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
07/10/2008, 16h40
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.
07/10/2008, 18h33
Invité2
Hum, oui, mais le message est tronqué donc j'avais du mal à identifier le problème, après quelques bugs malencontreux :

Citation:

)]+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:

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 ?
07/10/2008, 19h19
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:

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; };
08/10/2008, 14h45
Invité2

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

Citation:

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:

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

Par avance merci de votre aide
08/10/2008, 18h33
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 ?
08/10/2008, 18h40
Invité2

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

Code:

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

Je suis coincé

Par avance merci de votre aide
08/10/2008, 18h46
Florian Goo

Peux-tu coller le code de ta fabrique ?

La voilà :

Code:

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

08/10/2008, 19h12
Florian Goo

Peux-tu coller tous les appels à fabrique.ajoute() ?

Pour aller plus vite :

Code:

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
int main(int argc, char *argv[])
{
 
    Fabrique fabrique;
 
    fabrique.Ajoute("default", new default_langage);
    fabrique.Ajoute("cpp", new CPP);
 
    if(argc > 1)
    {
        Parser* Parseur = fabrique.Apppel(argv[1]);
 
        if(Parseur->existe)
        {
            boost::spirit::parse_info<> info =
            boost::spirit::parse(argv[2], *Parseur, boost::spirit::space_p);
        }
        else
        {
            std::cout << argv[2] << std::endl;
        }
    }
    else
    {
        std::cout << "Pas de texte a mettre en forme" << std::endl;
    }
 
    // on valide l'execution du programme
    return 0;
}

Par avance merci de votre aide,

PS : oui, je connais l'using namespace, mais j'aime pas ^^

Diantre, je cale…

Ça me saute pas aux yeux… essaie ça pour voir :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int main(int argc, char *argv[])
{
    if(argc > 1)
    {
        CPP cpp;
 
        boost::spirit::parse_info<> info =
        boost::spirit::parse(argv[2], cpp, boost::spirit::space_p);
    }
 
    return 0;
}

09/10/2008, 09h31
Invité2

Non, toujours le même problème...

Ca me parrait bien toufu...

Merci par avance de votre aide
09/10/2008, 10h43
Florian Goo

Comment ça, même problème ? Exactement le même message d'erreur que le post #16 ?
Comment est-ce possible d'avoir le même message d'erreur alors qu'on n'utilise plus la classe Parser :koi:
Ou alors tu t'en sers ailleurs dans ton code…

Peux-tu coller le message d'erreur, que je voie ça ?
09/10/2008, 12h38
Invité2

Bah, je vais te faire un zip, mais je m'en sert nul part ailleur

Message d'Erreur :

Citation:

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>]|

ZIP
09/10/2008, 14h40
Florian Goo

Je ne sais pas si tu es au courant, mais Firefox marque ton site comme étant une contrefaçon.

Enfin… le problème, je pense, vient de la fonction boost::spirit::parse(), qui est template. Un de ses arguments template est le type de parser que tu veux lui donner. C'est cette fonction qui essaie d'instancier un objet de type Parser::definition (la preuve, il suffit de commenter l'appel pour que le code soit compilable).
Tu ne peux pas faire de polymorphisme dynamique avec cette fonction. Il va donc falloir que tu fasses sans interface…
10/10/2008, 12h45
Invité2

ok, merci, tanpis