boost spirit (pb avec les espaces)

Version imprimable

Bonjour,
J'ai utilisé boost spirit pour lire et afficher une liste de chaines de caractères, mon problème c'est que le parseur ne prend pas en compte les espaces. voici un bout de code qui explique qu'est ce que j'ai fais :

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
 
 
bool PlanParser::parse(base_iterator_type first, base_iterator_type last)
{
   // using boost::spirit::space_p;
    bool r = boost::spirit::qi::/*phrase_*/parse(
        first,
        last,
        getParser(),
       // ,boost::spirit::qi::char_('!')//eoi//space
       // boost::spirit::space
    );
    if (first != last)
        return false;
    return r;
}
 
boost::spirit::qi::rule<base_iterator_type> PlanParser::getParser()
{
    return *((+(boost::spirit::qi::char_ - boost::spirit::qi::char_(':')))[newPlage]//[boost::bind(&PlanParser::newPlage, this, _1)]
        >> boost::spirit::qi::char_(':')
        >> (boost::spirit::qi::int_ >> boost::spirit::qi::char_('/') >> boost::spirit::qi::int_ >> boost::spirit::qi::char_('/') >> boost::spirit::qi::int_ )[startDate]//[boost::bind(&PlanParser::newPlage, this, _1)]
        >> boost::spirit::qi::char_('-')>> boost::spirit::qi::char_('>')
        >> (boost::spirit::qi::int_ >> boost::spirit::qi::char_('/') >> boost::spirit::qi::int_ >> boost::spirit::qi::char_('/') >> boost::spirit::qi::int_ )[endDate]//[boost::bind(&PlanParser::newPlage, this, _1)]
        >> boost::spirit::qi::char_(':')
        >> (+(boost::spirit::qi::char_- boost::spirit::qi::char_('.')))[name]
        >>boost::spirit::qi::char_('.')
        )
 
    ;
}

J'attend votre aide
Merci

Bonjour à nouveau,

Je me rend compte que je n'ai pas donné beaucoup de précisions dans mon premier message. Voici une explication plus avancée.

Je suis entrain d’essayer de parser une liste de chaines de caractères à l’aide de boost ::spirit.

Voici un exemple de la liste de chaine de caractères que je veux parser :
Code:

1 2 Georges Orwell : 01/01/09 -> 01/01/50 : disponible un jour sur deux. Steve O Connor : 01/08/09 -> 01/01/50 : disponible.
Mon but c’est d’obtenir en sortie :
Code:

1 2 3 4 a new plage for : Georges Orwell starting : 2009-Jan-01 ending : 2050-Jan-01 named : disponible un jour sur deux
Alors que j’obtiens comme sortie :
Code:

1 2 3 4 a new plage for : GeorgesOrwell starting : 2009-Jan-01 ending : 2050-Jan-01 named : disponibleunjoursurdeux
Mon problème c’est que le parseur skip les espaces, du coup j’obtiens 'GeorgesOrwell' au lieu de ‘Georges Orwell’.

Attention cependant, je veux skipper les espaces dans le reste de la phrase. Par exemple :

Code:

01/01/09 -> 01/01/50

est exactement équivalent à :

Code:

01/01/09->01/01/50

ou à

Code:

01/01/09 -> 01/01/50

J’ai essayé de mettre l’expression qui parse la chaine de caractère ‘Georges Orwell’ dans un lexeme pour inhiber le saut d’espace mais ca ne résout pas le problème.

Voici la définition de mon parser :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 boost::spirit::qi::rule<base_iterator_type> PlanParser::getParser() { using boost::spirit::qi; return *(lexeme[*(char_- char_(':'))][newPlage] >> char_(':') >> (int_ >> char_('/') >> int_ >> char_('/') >> int_ )[startDate] >> char_('-')>> char_('>') >> (int_ >> char_('/') >> int_ >> char_('/') >> int_ )[endDate] >> char_(':') >> (+(char_- char_('.')))[name] >>char_('.') ) ; }
et voici comment je l'utilise :
Code:

1 2 3 4 5 6 7 8 9 10 11 bool PlanParser::parse(base_iterator_type first, base_iterator_type last) { bool r = boost::spirit::qi::parse( first, last, getParser() ); if (first != last) return false; return r; }
Peut-être n'ai-je pas compris l'utilisation de lexeme, ou bien peut-être n'est-ce pas la bonne méthode ?

Merci à ceux qui auront eu la patience de lire et à ceux qui m'aideront

Ton parseur bien que peu clair je trouve a l'air correcte
Tu as deux methodes pour les espaces, soit tu les parses a la main, en gros tu cree une regle pour les parser (pas tres dure), soit tu dis a ton parseur de les consumer avec la regle predefinis: boost::spirit::ascii::space_type.

Sinon si je n'ai pas repondu a ta question, je n'ai pas compris ton erreur.

Cependant je me permet de te conseiller de separer tes regles. Genre tu fais une regle file, qui utilise une regle genre parseBidule, un bidule qui se decompose en un machinchose et un truc ...

Je te mets un exemple d'un parseur JSon pour que tu vois ce que je voulais dire par decomposition:
(c'est du spirit V2)

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
 
template<typename Iterator>
struct JSonGrammar : boost::spirit::qi::grammar<Iterator, JSonPair(), boost::spirit::ascii::space_type>
{
	JSonGrammar() :
	    JSonGrammar::base_type(json)
	{
 
	    using boost::spirit::qi::lit;
	    using boost::spirit::qi::lexeme;
	    using boost::spirit::ascii::char_;
	    using boost::spirit::ascii::string;
	    using namespace boost::spirit::qi::labels;
 
	    using boost::phoenix::at_c;
	    using boost::phoenix::push_back;
 
	    string_	=	lexeme[
					   '"' >>
					   *(
						   (char_('\\')[_val += _1] >> char_[_val += _1]) |
						   (char_[_val += _1]- '"')
					   )
					   >> '"'
 
	           	  	       ];
 
	    json 	= 	dict[_val = _1] | pair[_val = _1] | array[at_c<1>(_val) = _1];
 
	    dict 	= 	'{' >>	pair[_val += _1] % ',' >> '}';
 
	    array	=	'[' >> value[_val += _1] % ',' >> ']';
 
	    pair	=    	string_ [at_c<0>(_val) = _1] >> ':' >> value [at_c<1>(_val) = _1];
 
	    value	=	lit("null") [_val = reinterpret_cast<void*>(NULL)]
					| lit("true") [_val = true]
					| lit("false") [_val = false]
					| string_ [_val = _1]
					| qi::double_ [_val = _1]
					| array[_val += _1]
					| dict[_val += _1]
					;
 
	}
 
	boost::spirit::qi::rule<Iterator, std::string(), boost::spirit::ascii::space_type> string_;
	boost::spirit::qi::rule<Iterator, JSonPair(), boost::spirit::ascii::space_type> json;
	boost::spirit::qi::rule<Iterator, JSonPair(), boost::spirit::ascii::space_type> dict;
	boost::spirit::qi::rule<Iterator, JSonPair(), boost::spirit::ascii::space_type> pair;
	boost::spirit::qi::rule<Iterator, JSonValue(), boost::spirit::ascii::space_type> value;
	boost::spirit::qi::rule<Iterator, JSonValue(), boost::spirit::ascii::space_type> array;
};

Dans ce code je dis a toutes mes regles d'ignorer les espaces. J'annule cependant la regle avec lexeme dans la regle string_

25/01/2010, 23h53
amirabg

Bonsoir,

Tout d’abord merci beaucoup pour vos conseils que j’ai appréciés.

Peut être je n’ai pas bien expliqué, mais mon problème se résume sur le fait qu’au niveau du parsing dans des parties j’ai voulu ignorer les espaces

Citation:

01 /01/09->01/01/5

est equivalent à

Citation:

01 /01/0 9 -> 01/01/50

par contre, dans d’autres parties j’ai besoin de garder les espaces. par exemple pour les chaines :

Citation:

Georges Orwell

et

Citation:

disponible un jour sur deux

Pour plus d’informations, j’ai définit un seul parseur et qui m’a donnée comme résultat l’ignorance de tous les espaces (par contre je cherche une solution pour garder les espaces dans des parties).

J’espère que ce sera plus clair.

Merci
27/01/2010, 14h31
daedric

Soit tu mets des marqueurs genre "machin chose" et tu fais un lexeme dessus pour le parser et je pense qeu c la meilleur methode.

Sinon tu peux aussi parser en lexeme jusqu'au ':' ....

enfin a toi de voir
02/02/2010, 10h36
amirabg
Salut,
Merci encore pour votre aide.

J’ai essayé de mettre l’expression qui parse la chaine de caractère ‘Georges Orwell’ dans un lexeme pour inhiber le saut d’espace mais ca ne résout pas le problème.
Pour ce faire, voila qu’est ce que j’ai fais :
Code:

1 2 lexeme[*(char_- char_(':'))]
Est-ce que j’ai pas bien utilisé le lexème ?
16/02/2010, 23h11
daedric

Desole je viens de me souvenir de ce poste :)

Ajoute tu bien les caractere lu a ton consumer ?

genre j'aurais un truc comme ca moi:
lexeme[*(char_[_val += _1]- char_(':'))]