Parsing de fichier texte

Version imprimable

Hello,

J'aimerais implémenter un parser de fichiers texte, dont voici un exemple :
Code:

1 2 3 4 5 6 7 8 9 my_int = 1; // ceci est un commentaire my_float_1 = 3.14; my_float_2 = 1.00e5; my_string = "bonjour"; my_vector = (1.2, 3, // comment 5.46); // encore un commentaire my_text = ("a", "b", "c");
En parcourant caractère à caractère mon flux, je pense y arriver, mais je me demandais si je n'avais pas intérêt à utiliser une librairie d'expressions régulière, ou s'il n'existait pas un librairie permettant de faire du parsing à moindre cout.

Merci pour vos conseils.

11/12/2010, 20h43
3DArchi

Salut,
Boost.Regex pour les expressions régulières.
Boost.Spirit pour une grammaire un peu plus riche.
12/12/2010, 18h44
gege2009

Merci pour ces 2 liens.
J'ai retenu la solution Boost.Spirit qui semblait bien remplir mon besoin.

Malheureusement, sur des gros fichiers (50Mo), le parsing peine un peu. Il peut prendre 20 fois plus de temps qu'une ancienne librairie (entièrement codée à la main) que j'utilisais.

Du coup j'ai 2 questions :
1- J'utilise Spirit.Classics, or j'ai vu qu'une nouvelle version majeure Spirit V2 existait à présent : est-ce réellement plus rapide?
2- S'il faut que je code le parsing à la main, existe-t-il des "bases" à respecter, des méthodes qui ont fait leurs preuves?
3- Je n'ai pas testé les regexp encore, mais j'imagine que ça sera aussi poussif sur les gros fichiers non ?

Merci encore pour votre aide
19/12/2010, 14h22
gege2009

Donc finalement, j'ai codé le parser à la main. Du coup c'est vraiment très rapide. Attention juste aux std::string pour lesquels les std::string::push_back caractère à caractère sont très consommateurs. J'ai tout mis dans des char* bufferisés à l'avance que j'assigne à la fin.
19/12/2010, 15h26
Arzar

Bonjour,

Citation:

1- J'utilise Spirit.Classics, or j'ai vu qu'une nouvelle version majeure Spirit V2 existait à présent : est-ce réellement plus rapide?

Oui, spirit2 est bien plus rapide que spirit classic, car selon les auteurs un gros travail d'optimisation a été fait sur la V2. D'ailleurs je serais curieux de pouvoir le vérifier, donc si tu peux poster ta grammaire spirit.classic et un exemple d'utilisation, j'aimerais bien essayer de faire le portage.

Citation:

Donc finalement, j'ai codé le parser à la main. Du coup c'est vraiment très rapide.

Certes, mais par exemple est-ce que tu gères correctement les erreurs ? C'est un cas qui m'est arrivé : j'avais besoin il y a quelques temps de parser un document très simple (beaucoup plus simple que ton exemple) et j'avais fait le comparatif entre quelques règles spirit vs une petite machine à état codé à la main. La machine à état était en effet largement plus rapide, par contre il fallait que le document soit formaté à la perfection, car à la moindre erreur ma MaE partait en vrille et produisait un résultat complètement loufoque :mrgreen:

Hello, voici ma grammaire, merci pour ton aide

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
            definition(Syntax const &self)
            {
                myNumeric   = real_p;
                myString    = '"' >> *( ~ch_p( '"' ) ) >> '"';
                myVector    = '(' >> *( myNumeric >> *( "," >> myNumeric ) ) >> ')';
                myText      = '(' >> *( myString >> *( "," >> myString ) ) >> ')';
                myVariant   = myNumeric | myString | myVector | myText;
                myLetter    = alpha_p | ch_p( '_' );
                myAlphaNum  = myLetter | digit_p;
                myObject    = myLetter >> *( myAlphaNum );
                myAttribute = +myAlphaNum;
                myKey       = myObject >> *( ch_p( '.' ) >> myAttribute );
                myLine      = myKey >> str_p( "=" ) >> myVariant >> str_p( ";" );
                root         = * myLine;
            }

21/12/2010, 18h58
Emmanuel Deloget

J'aurais tendance à proposer Coco/R, qui génère parseur et lexers qui sont relativement efficaces à partir d'une grammaire LL1.
22/12/2010, 11h59
Goten

Citation:

Oui, spirit2 est bien plus rapide que spirit classic, car selon les auteurs un gros travail d'optimisation a été fait sur la V2. D'ailleurs je serais curieux de pouvoir le vérifier, donc si tu peux poster ta grammaire spirit.classic et un exemple d'utilisation, j'aimerais bien essayer de faire le portage.

Y'a des benchs un peu partout (bien que j'ai rien sous la main :p) mais c'est le jour et la nuit... (vraiment!).

De toute façon :
http://boost-spirit.com/home/2010/11...rs-37-seconds/

donc bon, je pense que ton fichier de 50 mo c'est pas un soucis... (j'en suis même sur pour l'avoir déjà fait :' )

Citation:

Envoyé par Emmanuel Deloget

J'aurais tendance à proposer Coco/R, qui génère parseur et lexers qui sont relativement efficaces à partir d'une grammaire LL1.

Et moi j'ai tendance à préféré avoir un DSEL plutôt qu'un fichier généré... comme quoi :>
22/12/2010, 13h09
jblecanard

J'aurais aussi tendance à te conseiller spirit V2 même si je ne suis pas vraiment expérimenté avec.

Citation:

Envoyé par gege2009

Attention juste aux std::string pour lesquels les std::string::push_back caractère à caractère sont très consommateurs. J'ai tout mis dans des char* bufferisés à l'avance que j'assigne à la fin.

Si tu conserves ta solution maison, tu peux utiliser des stringstream pour régler ce souci sans avoir à gérer des char* à la mano.
22/12/2010, 14h09
Emmanuel Deloget

Citation:

Envoyé par Goten

Et moi j'ai tendance à préféré avoir un DSEL plutôt qu'un fichier généré... comme quoi :>

Le résultat est plus ou moins équivalent. Après, certaines grammaires ne peuvent être parsées par un DSEL. Pour une grammaire LL1 simple, le DSEL est effectivement une solution correcte.

Pour ma part, désolidariser la définition de ma grammaire du reste du code me semble être une bonne chose - d'autant plus que certains générateurs de parseurs produisent un code tout à fait acceptable au niveau des performances, avec un learning step assez léger.

Au final, le résultat est censé être équivalent voire assez proche d'identique, donc c'est plus une question de goût :)
22/12/2010, 14h32
Jean-Marc.Bourguet

Un avantage d'un generateur, c'est que si la grammaire ne lui convient pas, il va te le dire. Un DSEL, tu as des chances qu'il ait un comportement exponentiel ou meme parte en boucle infinie face a une entree qui ne lui convient pas.

Et en particulier face a une grammaire stable si la qualite des messages d'erreur a de l'importance, ecrire le parseur a la main est aussi une option.