Bonjour,
 
Je m'arrache les cheveux avec mon faible niveau en perl et les regex
 
Voila je lis un fichier qui contient par exemple les lignes suivante :
 
(salon on ou baie vitree on) et (cuisine on ou entree on)  
Salon on et (entree on ou cuisine on) et baie vitree on
((salon on ou entree on) et (baie vitree on et cuisine on)) ou chambre on
 
et je veux transformer ces lignes en :
 
(/salon on/ || /baie vitree on/) && (/cuisine on/ || /entree on/)
/salon on/ && (/entree on/ || /cuisine on/) && /baie vitree on/
((/salon on/ || /entree on/) && (/baie vitree on/ && /cuisine on/)) || /chambre on/
 
j'ai écris le code suivant en supposant que $cond contient les lignes du fichier, lues une par une dans une boucle.
 

 
Je n’excuse par avance pour ce code de débutant, mais c'est compliqué et ça ne marche pas !!!!
 
Quelqu'un peut m'aider et me montrer le chemin à suivre ?
 
Par avance merci.

Déjà une astuce pour améliorer nettement la lisibilité: On peut utiliser un autre séparateur que '/' pour les regex, p.ex. s!ceci!cela!. Du coup on peut mettre des '/' directement sans devoir écrire "\/".

C'est peut-être pas élégant mais plus court et ça fonctionne. Par contre faut faire la liste des mots une fois pour le premier regex.

use strict;
use warnings FATAL => 'all';
 
my $texte=<<ENDT;
(salon on ou baie vitree on) et (cuisine on ou entree on)  
Salon on et (entree on ou cuisine on) et baie vitree on
((salon on ou entree on) et (baie vitree on et cuisine on)) ou chambre on 
ENDT
 
 
foreach my $cond (split(/\n/,$texte))
{
    $cond =~ s!((?:salon|baie vitree|cuisine|chambre|entree) on)!/$1/!g;
    $cond =~ s! ou ! || !g;
    $cond =~ s! et ! && !g;
    print $cond,"\n";
}
 
 
__END__
(/salon on/ || /baie vitree on/) && (/cuisine on/ || /entree on/)  
Salon on && (/entree on/ || /cuisine on/) && /baie vitree on/
((/salon on/ || /entree on/) && (/baie vitree on/ && /cuisine on/)) || /chambre on/

Ca sent la domotique...

Sans devoir faire la liste des mots, hautement expérimental!! (autrement dit à tester intensivement avant utilisation ou faire valider par un pro)

$cond =~ s!(^|\(|ou |et )([\w ]+?) on!$1/$2 on/!g;

(remplace le premier regex)

La routine replace reçoit une ligne et renvoie la ligne modifiée

my @data = ("(salon on ou baie vitree on) et (cuisine on ou entree on)  ",
        "Salon on et (entree on ou cuisine on) et baie vitree on",
        "((salon on ou entree on) et (baie vitree on et cuisine on)) ou chambre on " );
 
sub replace {
  my $line = shift;
  $line =~ s!^\s*!/!;
  $line =~ s!\s*$!/!;
  $line =~ s!(\(+)!$1/!g;
  $line =~ s!(\)+)!/$1!g;
  $line =~ s!\sou\s!/ || /!g;
  $line =~ s!\set\s!/ && /!g;
  $line =~ s!/\(!(!g;
  $line =~ s!\)/!)!g;
  return $line;
}
 
my @replaced = map{replace($_)} @data;
print join("\n", @replaced);

 
- D'abord je met des / en début et fin de ligne (si ils sont inutiles, ils seront effacés plus tard)
- Je remplace les (...( et )...) par (...(/ et /)...)
- Je remplace les ou et et par / || / et / && /
- Je vire les trucs qui devraient pas y être en remplaçant /( et )/ par ( et )
 
A+,

Bonsoir,
 
Déjà merci à vous 2.  
 
Je regarde ça en détail et je vous tiens au courant.
Gilou merci pour les explications à venir

Je viens de tester.
Gilou ça fonctionne parfaitement  
Rat de combat, effectivement je triture ma domotique à la maison  
Ta première solution fonctionne mais le script ne peut pas connaitre à l'avance le nom des capteurs. J'ai testé ta 2eme solution mais je me retrouve avec un / en trop au début et à la fin. Ceci dit chapeau quand même  
 
Un grand merci pour votre aide.

On peut optimiser un peu le sub (ou en tout cas en réduire la verbosité) ainsi:
 

sub replace {
  $_ = shift;
  s!^\s*!/!;
  s!\s*$!/!;
  s!(\(+)!$1/!g;
  s!(\)+)!/$1!g;
  s!\sou\s!/ || /!g;
  s!\set\s!/ && /!g;
  s!/\(!(!g;
  s!\)/!)!g;
  return $_;
}

 
A+,

Une petite note pour le rongeur guerrier:

use strict;
use warnings FATAL => 'all';
 
my $texte=<<ENDT;
(salon on ou baie vitree on) et (cuisine on ou entree on)  
Salon on et (entree on ou cuisine on) et baie vitree on
((salon on ou entree on) et (baie vitree on et cuisine on)) ou chambre on 
ENDT
 
 
foreach my $cond (split(/\n/,$texte))
{
    $cond =~ s!((?:salon|baie vitree|cuisine|chambre|entree) on)!/$1/!g;
    $cond =~ s! ou ! || !g;
    $cond =~ s! et ! && !g;
    print $cond,"\n";
}
 
 
__END__
(/salon on/ || /baie vitree on/) && (/cuisine on/ || /entree on/)  
Salon on && (/entree on/ || /cuisine on/) && /baie vitree on/
((/salon on/ || /entree on/) && (/baie vitree on/ && /cuisine on/)) || /chambre on/

Plutôt qu'un ENDT que tu lis de manière complexe, utiliser __DATA__ serait sans doute plus direct ici:
 

use strict;
use warnings FATAL => 'all';
 
while (<DATA> ) {
  s!((?:salon|baie vitree|cuisine|chambre|entree) on)!/$1/!g;
  s! ou ! || !g;
  s! et ! && !g;
  print;
}
 
__DATA__
(salon on ou baie vitree on) et (cuisine on ou entree on)  
Salon on et (entree on ou cuisine on) et baie vitree on
((salon on ou entree on) et (baie vitree on et cuisine on)) ou chambre on

 
A+,

Je ne vois pas, où ça? Le résultat de mon script correspond à celui du script de gilou...?

Merci gilou pour le coup du __DATA__, je connaissais pas.

Excuse rat de combat c'est moi qui faisais une erreur
Ta solution est donc encore plus "concentrée"
 
Merci à vous.

Euh, dans la solution de Rat de combat, il y a ce probleme: Salon n'est pas reconnu parce qu'il commence par une majuscule (début de la 2e ligne).
Il faut remplacer la ligne
s!((?:salon|baie vitree|cuisine|chambre|entree) on)!/$1/!g;
par
s!((?:salon|baie vitree|cuisine|chambre|entree) on)!/$1/!gi;
avec un i (case independent) pour régler le problème.
Et il vaut mieux mettre des \s+ dans ce genre d'expression:
s!((?:salon|baie\s+vitree|cuisine|chambre|entree)\s+on)!/$1/!gi;
A+,

Merci Gilou, comme je ne connais pas le nom des capteurs il faut que j'utilise ta méthode ou la 2eme de rat de combat.
 
Je me permets de vous poser une autre question.
J'ai 2 tableaux, comment on peut les comparer ligne par ligne et trouver les lignes différentes (changement d'état).
 
Merci.

En utilisant le module Text::Diff, je pense.
 
A+,