RegEx - Ignorer des bloques

Version imprimable

01/10/2013, 11h45
WilMon

RegEx - Ignorer des bloques

Bonjour,

Je souhaites sélectionner toutes les expressions de la forme xx=yy et qui se trouvent en dehors d'accolades. Par exemple dans

a=5 { xxxx y=7 zz u=8 oo } iiii b=7

ne sera sélectionné que a=5 et b=7.

J'imagine qu'il faut utiliser lookahead et lookbehind mais je ne vois pas vraiment comment :?

Merci !
01/10/2013, 13h28
6ril23
est ce que tu peux avoir plusieurs accolades sur une même ligne?

cette regex te permet déjà d'avoir ce qui se trouve en dehors des accolades
Code:

1 2 3 4 5 6 my $l='a=5 { xxxx y=7 zz u=8 oo } iiii b=7'; if ( $l =~ /(.*)\{(.*)\}(.*)/ ){ print "$1 // $3\n"; } -->a=5 // iiii b=7
Ensuite, tout dépend du format de la ligne alors pourrais tu indiquer si tu peux avoir plusieurs xx=yy avant et/ou plusieurs xx=yy après '{}', plusieurs accolades...
01/10/2013, 13h33
cmcmc

Bonjour WilMon,

Citation:

J'imagine qu'il faut utiliser lookahead et lookbehind mais je ne vois pas vraiment comment

regarde plutôt du côté de (?PARNO) (?-PARNO) (?+PARNO) (?R) (?0) dans perlre. Tu y trouveras une expression régulière permettant d'isoler un un groupe de parenthèses imbriquées, qu'il est facile d'adapter pour des accolades.

Dans ton cas les accolades semblent jouer le rôle de commentaires. Une stratégie possible consiste à utiliser dans un premier temps l'expression régulière ci-dessus pour les filtrer (les éliminer du texte inital), et faire dans une seconde étape les recherches sur le texte ainsi simplifié.

Par contre tu auras besoin d'un perl récent (qui comprenne (?PARNO)). Si les accolades ne sont pas imbriquées tu peux t'en sortir avec la même stratégie générale en utilisant une expression régulière plus simple et qui sera compréhensible pour les anciens perls.

N'hésite pas à revenir à la charge si ça ne te paraît pas clair.
01/10/2013, 13h51
disedorgue
Bonjour,
Surtout que cela peut se compliquer si l'on doit considérer les cas du type:
Code:

1 2 3 4 a=5 { b=6 c=7 } d=8
:aie:
01/10/2013, 14h31
WilMon
Merci pour vos réponses !

Pour être plus clair je vais expliquer mon problème. Je souhaites en fait parser du code R pour repérer toutes les affectations de variables réalisées en dehors d'accolades ou de parenthèses. Par exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 a = 5 f1 = function() { b=1 c=2 try({eval(parse(text='a'))}) return(b+c) } c=7
je devrais avoir
a = 5 et c = 7

Les parenthèses et accolades peuvent donc être imbriquées.
Merci cmcmc pour l'astuce de PARNO je ne connaissais pas cette manière, avec ça il me suffirait en effet de faire une première passe ou je supprimerais les parties inintéressantes puis une seconde ou je récupère les affectations.
Mais est-il possible de regrouper ces deux étapes en une seule regex ? (j'en demande peut être un peu trop là :oops:)
01/10/2013, 15h14
cmcmc
Citation:

Envoyé par WilMon

...
Les parenthèses et accolades peuvent donc être imbriquées.
Merci cmcmc pour l'astuce de PARNO je ne connaissais pas cette manière, avec ça il me suffirait en effet de faire une première passe ou je supprimerais les parties inintéressantes puis une seconde ou je récupère les affectations.
Mais est-il possible de regrouper ces deux étapes en une seule regex ? (j'en demande peut être un peu trop là :oops:)

Je n'ai pas le temps de regarder maintenant. Peut être, mais sans doute au détriment 1) de la clarté, 2) des performances...

quelque chose comme (non testé) :
Code:

1 2 3 4 5 6 my $braces = qr/({(?:[^{}]++|(?-1))*+})/; my $assign = ...; # affectation while ($text =~ /(:?$braces|.*?)*?($assign)/msg) { # faire quelque chose de $1 }
L'alternation (|) en particulier peut poser des problèmes.

Tu peux peut être aussi essayer de virer le /g et de capturer les affectations au fur et à mesure via (?{...}) dans une expression régulière qui couvrirait l'ensemble de tes fichiers d'entrée (exemple ici).

si on considère que tu as un fichier tu peux essayé ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
open(FH_IN, $file) or die "Ouverture fichier impossible\n";
my $enrg = 'ok';
while (<FH_IN>){
     if ( $_ =~ /\{/ ){
          $enrg = 'ko';
          next;
     }
     elsif ( $_ =~ /\}/ ){
          $enrg = 'ok';
          next;
     }
     elsif ( $enrg eq 'ok' and $_ =~ /((\w+)\s?=\s?(\d+))/ ){
          print "Affectation: $1\n";
     }
}

Résultat:

Code:

1
2
3
-bash-3.00$ perl test.pl
Affectation: a = 5
Affectation: c=7

Je repasserai pour essayer d'optimiser tout ça.

en plus il semble qu'il faille filtrer les définitions de fonctions... J'aurais tendance à rester sur la version en deux passes
Code:

1 2 3 4 5 6 7 8 9 10 11 # parse2.pl use strict; use warnings; use 5.018; my $braces = qr/({(?:[^{}]++|(?-1))*+})/; my $left = qr/\w+/; # a raffiner my $right = qr/\d+/; # qu'est ce qu'on peut faire figurer en partie droite ? quid de function ... ? my $assign = qr/$left\s*=\s*$right/; say for do { local $/; <> } =~ s/$braces//msgr =~ m/$assign/msg;
qui donne pour ton exemple

Citation:

Taisha:~/tttmp/ignorer_les_bloques $ perl parse2.pl filein
a = 5
c=7
Taisha:~/tttmp/ignorer_les_bloques $

02/10/2013, 17h46
WilMon

Ok je pense que je vais faire comme tu as dis cmcmc. Merci ! :)