Forum Programmation.autre Captures dans une regexp

Posté par (page perso) .
0
31
mai
2006
Bonjour, j'ai encore un problème de capture dans une expression rationelle. Je bute souvent dessus et ne trouve pas de doc clair sur le sujet

J'utilise
http://www.weitz.de/regex-coach/ pour tester mes regexp. Ce programme n'est pas libre, mais il me convient très bien. Il est compatible regexp perl et pour avoir conçu avec des regexp assez tordues, je suis sûr qu'il est vraiment compatible.

Mon problème :

J'ai diverses phrases du genre

MINORE (NOMINAL)
ou
VOIR TABLE TRUC (OPT)
ou
TRANSF EN PAR TRUC TOTO TITI TUTU

Bref, j'ai en gros :

pour
param := <\w>
Mot := \w

((Mot*\s*)*param*)*

J'ai conçu la regexp suivante qui semble matcher pour tous les cas que je lui ai donné à manger.
[\(\)\w\s]*<*(\w+)>*([\(\w\s]*(<*\w+>*))*[\w\)]

Le problème, c'est les captures...

Très souvent, avec des constructions de ce style qui s'approchent d'une grammaire BNF (et j'ai pas d'outil sous la main pour les traiter avec le langage* que je suis obligé d'utiliser), je bute sur ces captures.

Logiquement, pour ma petite tête, si j'utilise une regexp du style ((Mot*\s*)*(param)*)*
et que j'ai TRANSF EN PAR TRUC TOTO TITI TUTU

Je devrai avoir capture n°1 : TRANSF EN
capture n°2 :
capture n°3 : PAR TRUC
capture n°4 :
capture n°5 :TOTO TITI TUTU
capture n°6 :

Alors même ça c'est un compromis, car dans l'idéal, je voudrai bien avoir une regexp dont les captures ne sont que les paramètres entre cochets...

Comme vous l'aurez constaté, je suis un peu perdu. Quelqu'un dans la salle a t-il une idée ?

*Je suis en windev (oui je sais c'est *sale*, mais j'ai pas le choix) dans ce cas précis et je ne possède qu'une et une seule fonction qui me permet de tester une regexp et de récup les n captures.
(7 commentaires).

  • # kodos

    Posté par . Évalué à 2.

    salut,

    Pourrais-tu mieux expliquer ton problème ?

    En tous cas, la regexp ((Mot*\s*)*(param)*)*, ça marche pas.
    Il faudrait plutôt un truc du style : ((\w\s+)*)

    • [^] # Re: kodos

      Posté par (page perso) . Évalué à 2.

      Reprenons depuis le début...

      Dans le cas général, supposons que j'ai une chaine du style

      motclé1 motclé2 motclé3 <param1,param2> motclé4 param3 motclé4

      Bref une chaine avec une grammaire BNF du style

      mot ::= motclé1 | motclé2 | motclé3
      param ::= '<' 'a'..'z'* ['a'..'z'] '>'
      phrase ::= mot [mot ]* param[',' param]

      J'ai plein de chaîne de ce style et je voudrai récupérer les paramètres.

      Un pays bien organisé est celui où le petit nombre fait travailler le grand nombre, est nourri par lui, et le gouverne - Voltaire

      • [^] # Quelqu'un dans la salle a t-il une idée ?

        Posté par (page perso) . Évalué à 3.

        Oui :
        1) Utiliser les expressions régulières pour l'analyse lexicale
        2) Effectuer une analyse syntaxique via descente récursive ou utiliser un générateur de parseur

      • [^] # RE : regexp

        Posté par . Évalué à 2.

        avec une regexp : .*<([^>]*)>.* tu récupères tes paramètres.

        et ensuite, tu sépares suivant les virgules.

        • [^] # Re: RE : regexp

          Posté par (page perso) . Évalué à 2.

          Sympa, merci, mais le problème, c'est qu'il ne me sort qu'une seul capture qui correspond au dernier paramètre. C'est normal ?

          Un pays bien organisé est celui où le petit nombre fait travailler le grand nombre, est nourri par lui, et le gouverne - Voltaire

  • # sed

    Posté par . Évalué à 2.

    je suis pas trop sûr que ça colle dans ton environnement (j'ai pas bien tout saisi), mais
    avec un coup de sed, ça donne ça :

    echo TRANSF EN PAR TRUC TOTO TITI TUTU | sed -e 's/\(\w\+\)\s\+\(\w\+\)\s\+/\1 \2\n/g'

    • [^] # Re: sed

      Posté par . Évalué à 2.

      en relisant l'énoncé de départ, il faut adapter ma proposition pour gérer les parenthèses dans les données en entrée

Envoyer un commentaire

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.