IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Boost C++ Discussion :

[BOOST.Spirit] Absence génante


Sujet :

Boost C++

  1. #1
    Invité2
    Invité(e)
    Par défaut [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 :

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

  2. #2
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    Salut,

    Qu'est ce que le type Parser, exactement ?
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  3. #3
    Alp
    Alp est déconnecté
    Expert confirmé

    Avatar de Alp
    Homme Profil pro
    Inscrit en
    Juin 2005
    Messages
    8 575
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations forums :
    Inscription : Juin 2005
    Messages : 8 575
    Par défaut
    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 ?

  4. #4
    Invité2
    Invité(e)
    Par défaut
    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...

  5. #5
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    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
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  6. #6
    Invité2
    Invité(e)
    Par défaut
    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;
     
    };

  7. #7
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    Ç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.
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  8. #8
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    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.
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  9. #9
    Invité2
    Invité(e)
    Par défaut
    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...

  10. #10
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    Tu as raté mon dernier message
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  11. #11
    Invité2
    Invité(e)
    Par défaut
    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 ===|

  12. #12
    Invité2
    Invité(e)
    Par défaut
    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

  13. #13
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    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.
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  14. #14
    Invité2
    Invité(e)
    Par défaut
    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 ?

  15. #15
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    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;
    };
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  16. #16
    Invité2
    Invité(e)
    Par défaut
    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

  17. #17
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    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 ?
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  18. #18
    Invité2
    Invité(e)
    Par défaut
    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

  19. #19
    Membre chevronné
    Avatar de Florian Goo
    Profil pro
    Inscrit en
    Septembre 2008
    Messages
    680
    Détails du profil
    Informations personnelles :
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Septembre 2008
    Messages : 680
    Par défaut
    Peux-tu coller le code de ta fabrique ?
    Cours : Initiation à CMake
    Projet : Scalpel, bibliothèque d'analyse de code source C++ (développement en cours)
    Ce message a été tapé avec un clavier en disposition bépo.

  20. #20
    Invité2
    Invité(e)
    Par défaut
    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

Discussions similaires

  1. Boost::Spirit : Comment fonctionne assign_a ?
    Par Shenga dans le forum Boost
    Réponses: 3
    Dernier message: 13/03/2009, 21h05
  2. Boost::Spirit : Encapsuler le parseur et ses résultats.
    Par JulienDuSud dans le forum Boost
    Réponses: 9
    Dernier message: 23/02/2009, 13h58
  3. boost::spirit trace et avancement.
    Par 3DArchi dans le forum Boost
    Réponses: 3
    Dernier message: 13/10/2008, 09h37
  4. [BOOST.Spirit] Types de bases inéxistant
    Par Invité2 dans le forum Boost
    Réponses: 4
    Dernier message: 14/09/2008, 21h31
  5. Comment utiliser Boost::spirit ?
    Par kimels dans le forum Boost
    Réponses: 8
    Dernier message: 11/06/2008, 19h04

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo