Regex POSIX et C non fonctionnelle

Bonjour à tous,

Je viens vers vous aujourd'hui suite à un souci que je rencontre actuellement concernant la mise en place d'une expression régulière dans une application. Le but de cette application est de faire transiter par trames réseaux des messages simples encodés d'une manière simple à ce que ce dernier puisse être décrypté. Pour information, j'ai regardé du côté de la sérialisation de structure en C cependant ceci semble requérir une/des librairies supplémentaires ce que je ne veux pas imposer à l'utilisateur.

Par exemple, l'un des messages que j'envoie ressemble à ceci :

Code:

---

salon=1;joueur=5;action=2;x=7

---

Où salon, joueur, action et x sont des éléments qui correspondent à une structure que j'ai nommée "Message" et qui porte ces différents attributs. Une regex PECL pour cette chaîne serait :

Code:

---

(([a-z]+)=([0-9]+);*)+

---

cependant j'ai eu le bonheur d'apprendre qu'en C, la norme des expressions régulières était POSIX. J'ai donc tenté tout naturellement :

Code:

---

([[:alpha:]][=][[:digit:]];*)+

---

Cependant pour le message ci-dessus, aucune correspondance n'est trouvée. Si par contre j'hôte le dernier quantificateur et les parenthèses comme ceci :

Code:

---

[[:alpha:]][=][[:digit:]];*

---

alors des patterns sont trouvés. Je ne comprends pas pourquoi les parenthèses rendent l'ensemble non fonctionnel alors que ces dernières ont bien pour usage de définir des "groupes" auxquels il est possible d'affecter des quantificateurs.

Auriez-vous des pistes ? Si non, auriez-vous des suggestions plus intéressantes concernant le transfert des données depuis une structure ?

Merci encore pour votre réponse, en vous souhaitant une bonne et agréable journée

Cr3a_Hal0

Citation:

---

Envoyé par Cr3a_Hal0

Une regex PECL pour cette chaîne serait :

Code:

---

(([a-z]+)=([0-9]+);*)+

---

cependant j'ai eu le bonheur d'apprendre qu'en C, la norme des expressions régulières était POSIX. J'ai donc tenté tout naturellement :

Code:

---

([[:alpha:]][=][[:digit:]];*)+

---

Cependant pour le message ci-dessus, aucune correspondance n'est trouvée

---

Bonjour

[:alpha:] symbolise un alphabétique. Pour correspondre avec ta regex précédente, il faut lui rajouter l'effet de répétition "+" avant de demander le "=" (perso je préfère écrire {1,} mais je ne sais pas si c'est POSIX...)

Sinon je ne m'explique pas cette étoile finale. Le point-virgule de séparation pourrait être suivi de n'importe-quoi avant que le motif alpha=valeur soit répété ?

Citation:

---

Envoyé par Cr3a_Hal0

Si non, auriez-vous des suggestions plus intéressantes concernant le transfert des données depuis une structure ?

---

Déjà il faut savoir que les compilos, pour optimiser, rajoutent parfois des octets bidons entre les membres d'une structure. Ca permet de tailler la structure sur un mot machine. Mais comme ça peut varier d'une architecture à une autre, si tu bazardes toute ta structure en binaire sur ta socket avec un write(socket, &data, sizeof(structure)) tu prends le risque de ne rien avoir de correct de l'autre coté (sauf si t'es sur la même architecture avec le même compilo).
C'est pour ça que pour être compatible, t'es obligé de sérializer et comme je ne connais pas d'outil C, si moi je sérializais ma structure je le ferais à la main (envoi du premier champ, puis envoi du second et etc). Je me ferais éventuellement mon propre sérializeur qui écrirait par exemple ma structure en ascii via sprintf() dans un tampon unique et de l'autre coté je pourrais la récupérer via sscanf()....

Bonjour !

Tout d'abord, merci pour votre réponse rapide :)

J'ai suivi votre conseil et procédé à la modification de la regex :

Code:

---

([[:alpha:]]+)[=]([[:digit:]]+)(;?)

---

Malheureusement aucun pattern n'est détecté pour le message indiqué plus haut. Je persiste à croire que les parenthèses mettent la zone, car même pour l'exemple d'au-dessus, le x=5 aurait pu être repéré .

En ce qui concerne le * de fin (après le point-virgule) ce dernier indique qu'il peut y avoir 0 ou x signes ";" après chaque séquence, car il me semble que le quantificateurs s'applique à l'élément qui le précède, ici le ";". Après, je conviens qu'il aurait été plus judicieux de mettre un "?".

Merci pour le tip sur les structures, je tâcherais d'y réfléchir :)

Petite réponse pour signaler que j'ai trouvé d'où venait le problème.

J'ai changé le dernier argument de regcomp en :

Code:

---

1 2	regcomp(&regex, "([[:alpha:]]+)[=]([[:digit:]]+)(;?)", REG_EXTENDED|REG_NEWLINE);

---

et cela fonctionne, les parenthèses ne posent plus problème.

Merci encore Sve@r pour votre réponse :) Très bonne journée

Cr3a

Citation:

---

Envoyé par Sve@r

je préfère écrire {1,} mais je ne sais pas si c'est POSIX

---

Ça l'est tout à fait. Il y a deux versions de regex POSIX, la version basique (BRE) et la version étendue (ERE).

À l'origine dans la version basique les opérateurs +, ? et | n'existent pas (ce qui est très pratique surtout pour le dernier.). Les solutions pour obtenir a+ sont donc aa* ou a\{1,\}.

Maintenant plusieurs implémentations des BREs sont plus souples et ont introduit +, ? et |. Ce n'est pas le cas en C, mais ça l'est pour par exemple GNU sed. Néanmoins ces trois signes doivent être échappés comme les parenthèses et les accolades pour ne pas être vus comme des caractères littéraux.

Donc en version BRE la pattern serait (attention en C, il faut doubler les échappements):

Code:

---

\\([[:alpha:]]\\{1,\\}\\)=\\([[:digit:]]\\{1,\\}\\);\\{0,1\\}

---

En version étendue ERE:

Code:

---

([[:alpha:]]+)=([[:digit:]]+);?

---

(inutile de mettre le = dans une classe de caractère vu qu'il s'y retrouve tout seul, ni de capturer le point virgule.)

Dans les deux modes, rien n'empêche de remplacer [[:alpha:]] par [a-zA-Z] et [[:digit:]] par [0-9].

juste pour bien marqué le coup, [[:alpha:]] est une classe [] contenant la pseudo [:alpha:], qui désigne les caractères alphabétiques.

Attention, selon les locales, ca peut aussi être les lettres accentuées, les cédilles, etc. Or, ceux-ci peuvent être placés en dehors des intervales a-z et A-Z.

Pour de l'anglais/ascii, toute fois, ca suffira.