Syntaxe et sémantique

Nouveaux quantifieurs

Pour compléter les quantifieurs déjà disponibles, une nouvelle série a été introduite, les quantifieurs possessifs, qui, quand un motif ne correspond pas, l'empêchent de revenir en arrière (backtrack).

    *+      correspond 0 ou plusieurs fois, et ne rend jamais
    ++      correspond 1 ou plusieurs fois, et ne rend jamais
    ?+      correspond 0 ou 1 fois, et ne rend jamais
    {n}+    correspond exactement n fois et ne rend jamais
    {n,}+   correspond au moins n fois et ne rend jamais
    {n,m}+  correspond au moins n fois mais pas plus que m fois, 
            et ne rend jamais

Voici un exemple pour comprendre la différence avec les quantifieurs déjà existants :

    "aaaa" =~ /(a+)a/;   # $1 contient "aaa"
    "aaaa" =~ /(a+?)a/;  # $1 contient "a"
    "aaaa" =~ /(a++)a/;  # échoue

La troisième expression, qui utilise un quantifieur possessif, échoue car /a++/, comme /a+/ va essayer de faire correspondre le plus de "a" possible, mais contrairement à /a+/, il n'essaye pas avec moins de caractères si cela échoue au premier coup. Cela permet donc d'éviter de coûteux retours arrière dans les expressions complexes.

Nouveaux verbes

Le moteur d'expressions régulières de Perl est basé sur un automate à états finis non-déterministe ou NFA (Nondeterministic Finite Automaton), qui utilise le retour arrière (backtracking) pour offrir des fonctionnalités avancées comme les références arrières (ce qui fait d'ailleurs que ces expressions ne sont pas très régulières, au sens mathématique du terme). En principe, les expressions régulières sont déclaratives, et ne dépendent pas de leur implémentation. Toutefois, le retour arrière a un coût non négligeable en terme de temps d'exécution, et c'est pourquoi au fil du temps, la grammaire s'est enrichie pour permettre un meilleur contrôle du retour arrière. On vient d'en voir un exemple avec les nouveaux quantifieurs, qui permettent d'empêcher le retour arrière sur des sous-motifs. Comme c'était malgré tout insuffisant pour certaines utilisations très avancées, des verbes ont été ajoutés afin d'offrir un contrôle très fin, pour limiter ou au contraire forcer le retour arrière.

La forme générale de ces verbes est (*VERB:ARG), l'argument étant généralement optionnel, et dans certains cas totalement absent. Quand un motif contient un de ces verbes, Perl positionne les variables globales $REGERROR et $REGMARK :

en cas de succès, $REGERROR est fausse et $REGMARK contient le nom du dernier (*MARK:NAME) exécuté ;
en cas d'échec, $REGMARK est fausse et $REGERROR contient l'argument passé au dernier verbe exécuté, ou s'il n'y en avait pas le nom du dernier (*MARK:NAME) exécuté, ou sinon une valeur vraie.

Ces variables ne sont pas magiques mais sont simplement globales, comme $AUTOLOAD, et peuvent donc être rendues locales à un bloc avec local.

Ces verbes sont marqués expérimentaux, mais au vu des précédentes fonctionnalités des expressions marquées expérimentales, il est assez probable qu'ils seront conservés. Les verbes actuellement disponibles sont les suivants :

(*FAIL), (*F)
Le plus simple verbe, qui est véritablement du sucre syntaxique pour (?!), permet de forcer le moteur à effectuer des retours arrière afin de déterminer toutes les correspondances possibles. C'est donc similaire à la recherche exhaustive de Perl 6.
(*ACCEPT)
Ce verbe provoque l'acceptation de la correspondance courante du motif, au point où est situé (*ACCEPT). Yves Orton le décrit comme un genre d'instruction return pour les expressions régulières.
(*PRUNE), (*PRUNE:NAME)
Quand le moteur effectue un retour arrière sur ce verbe, il fait échouer la correspondance à la position de départ courante. C'est similaire à (?>..) sauf que (*PRUNE) est unaire alors que (?>..) est une construction de sous-motif.

On l'appelle "prune" ("tailler" en anglais, un terme de jardinage) parce qu'il sert à tailler l'arbre de recherche de retours arrières en supprimant les branches qu'on sait ne pas vouloir parcourir.
(*SKIP), (*SKIP:NAME)
(*SKIP) est similaire à (*PRUNE), à la différence qu'en cas de retour arrière par échec, il indique au moteur de sauter jusqu'au point où il se situe. Si un nom est donné en argument, le moteur sautera jusqu'au point marqué avec ce nom par (*MARK).
(*MARK:NAME), (*:NAME)
Ajouté pour répondre aux besoins de certains programmes exigeants comme SpamAssassin, ce verbe permet de marquer la position courante dans la chaîne et de lui donner un nom.
```
    /zlonk+(*MARK:zlonk)|qunck+(*MARK:qunck)|cr+a+ck(MARK:crack)/
```
Cela permet entre autres de voir le chemin suivi par le moteur pour faire correspondre le motif à la chaîne, et facilite donc grandement le débuggage.
(*THEN), (*THEN:NAME)
Comme son nom le laisse supposer, ce verbe fournit un genre d'instruction if/then pour expressions régulières. Conçu pour être utilisé au sein d'un groupe d'alternatives, revenir sur ce verbe fait passer le moteur à la branche suivante, réalisant donc l'équivalent d'un else.
```
    /( COND1 (*THEN) SUBPATTERN1 | COND2 (*THEN) SUBPATTERN2 )/x
```
Utilisé en dehors d'un groupe d'alternatives, ce verbe est équivalent à (*PRUNE). Il existe en Perl 6 sous le nom d'opérateur cut group, noté ::.
(*COMMIT)
Ce verbe est l'équivalent du motif commit de Perl 6, où il s'écrit <commit> ou :::. Il est similaire à (*SKIP), sauf que quand le moteur fait un retour arrière dessus pour cause d'échec, il provoque un arrêt immédiat par échec de la correspondance.

Captures

Les captures sont disponibles en Perl depuis le début, mais la manière de s'y référer a évolué (en bien) au fil des années. Ainsi au début on pouvait se référer aux parenthèses capturantes avec la syntaxe traditionnelle \N, où N est le numéro de la parenthèse ouvrante (en comptant à partir de la gauche).

    "moo" =~ /(\w)\1/   # détecte des caractères dupliqués

Cette notation marche, mais pose problème quand on a plus de 10 captures. En effet, Perl a normalement l'habitude de traduire \10 par \010, c'est-à-dire le caractère ASCII 8 (backspace) en notation octale. Pour éviter les problèmes, Perl ne résout \10 comme une référence de capture que si au moins 10 captures ont été déclarées. Et de même pour \11, \12, etc. Néanmoins, cela rend le code assez confus et cette syntaxe ne peut être utilisée qu'au sein d'une expression régulière. Hors de l'expression, on dispose des variables numérotées (cette fois-ci en base décimale) $1, $2, $3... pour se référer aux captures et récupérer leurs valeurs.

Un autre aspect qui rend l'utilisation de nombreuses captures assez complexe est qu'elles sont numérotées dans l'ordre d'apparition, de gauche à droite, sans tenir compte de la notion d'alternative. H. Merijn Brand a proposé pour cela une première solution, la remise à zéro de branche (branch reset pattern). C'est un groupe non-capturant, comme (?:...), mais noté (?|...) et qui permet de numéroter les captures de chaque branche de l'alternative comme si elle était seule. Les captures suivant l'alternative sont ensuite numérotées par rapport à la branche contenant le plus de captures. L'exemple suivant, qui pourrait lire un format de log, illustre comment s'effectue cette numérotation :

    m{
        # 1: date ISO,  2: hôte,  3: processus
            (\d+T\d+) \s+ (\S+) \s+ (\S+) \s+
            (?|
                # 4: msgid,  5: liste de clés-valeurs
                    (\w+): \s+ ( (?: \w+=\S+,?)+ \s+ )
                |
                # 4: msgid, 5: sens,       6: liste de clés-valeurs
                    (\S+) \s+ (=>|<=|==) \s+ ( (?: \w+=\S+)+ \s+ )
                |
                # 4: msgid,      5: reste de la ligne
                    (\d+\.\d+) \s+ (.+?)
            )
            #          7: statut
            -> status: (\w+)
    }x;

Étant assez simple à implémenter, cette fonctionnalité a rapidement été ajoutée dans PCRE (voir la section Duplicate subpattern numbers).

Néanmoins, le fait même de numéroter pose problème dès que l'on désire construire de grandes expressions par concaténation et interpolation de morceaux atomiques. On se retrouve obligé de jongler pour s'y retrouver, et cela devient rapidement un casse-tête si certains morceaux sont dynamiquement modifiables. Imaginez ce que cela donne pour un module comme Regexp::Common !

Perl 5.10 offre une réponse en proposant une nouvelle syntaxe, \g{N}, où N peut maintenant être un entier positif ou négatif. Positif, cela correspond au numéro habituel de la capture. Négatif, c'est une référence relative arrière, qui correspond donc à la N-ième capture précédente. Ainsi, \g{-1} se réfère à la précédente capture et \g{-2} à celle qui la précède (la pénultième). On peut ainsi écrire un morceau d'expression qui détecte les mots en double :

    my $find_dup = qr/ (\w+) \s+ \g{-1} /x;

et qui peut maintenant être interpolé sans problème au sein d'une expression plus importante.

Encore mieux, on peut en plus donner un nom aux captures, afin de s'y retrouver plus facilement. La syntaxe pour déclarer et référencer les captures nommées est reprise de celle de .Net : on utilise la syntaxe (?<name>pattern) pour les déclarer et \k<name> pour les rappeler. On peut aussi utiliser \g{name} si on préfère. La variation (?'name'pattern) / \k'name', ainsi que la syntaxe Python ((?P<name>pattern) / ()) sont supportées pour faciliter la passage des expressions régulières entre les différents langages. Le détecteur de doublons peut maintenant s'écrire :

    my $find_dup = qr/ (?<dup_word>\w+) \s+ \k<dup_word> /x;

Il faut noter que \k<name> se réfère toujours à la première capture nommée "name" définie (c'est-à-dire la première qui a réussi), y compris quand plusieurs captures utilisent le même nom. Tout ceci rend donc quasiment trivial l'utilisation de bouts d'expressions comme ce détecteur de doublons au sein d'expressions plus grandes.

Hors de l'expression même, on dispose des variables %+ et %- pour accéder aux captures : $+{name} qui est identique à \k<name>, et $-{name} (qui est une référence vers un tableau) pour avoir toutes les captures de ce nom, même celles qui n'ont pas correspondu. Il faut noter que ces variables ne sont disponibles que dans le bloc lexical correspondant à l'expression régulière de définition.

    while ($text =~ /$find_dup/gsm) {
        print "mot en double : $+{dup_word}\n";
    }

Un dernier point intéressant est que %+ et %- sont en réalité de simples variables rendues spéciales par le module Tie::Hash::NamedCapture, ce qui autorise donc l'utilisation d'autres variables si on trouve que celles par défaut ont un nom trop obscur.

    use Tie::Hash::NamedCapture;
    tie my %last_match, "Tie::Hash::NamedCapture";
    # %last_match se comporte maintenant comme %+

    tie my %reg_buffer, "Tie::Hash::NamedCapture", all => 1;
    # %reg_buffer se comporte maintenant comme %-

Motifs récursifs

Perl avait déjà un mécanisme pour construire des expressions régulières récursives, utilisant le constructeur de motifs dynamiques (??{ code }). Ainsi, l'exemple suivant permet de reconnaître en perl 5.8.X des groupes de parenthèses imbriquées :

  $re = qr{ (           # groupe #1
                        \(             # parenthèse ouvrante
                        (?:
                              (?> [^()]+ )    # groupe sans retour arrière
                          |
                              (??{ $re })     # groupe avec parenthèses 
                        )*
                        \)             # parenthèse fermante
                      )
                  }x;

Cela fonctionne par une interpolation de l'expression au sein d'elle-même, réalisée à l'exécution du programme. Mais c'est assez inélégant car c'est une solution externe au moteur d'expressions régulières, ce qui impose des limitations (la variable à interpoler doit être globale) et des lourdeurs (l'expression est complexe, et c'est globalement lent).

Pour cette raison, la syntaxe existante de PCRE, bien plus complète et efficace, a été importée dans Perl 5.10. Le principe est de permettre de ré-invoquer un groupe capturant avec (?PARNO), où PARNO est le numéro de parenthèse (c'est-à-dire du groupe). Si ce nombre est précédé d'un signe, alors il est compris de manière relative. Ainsi (?2) invoque le 2e groupe déclaré, (?-1) le dernier groupe déclaré, et (?+1) le prochain groupe qui sera déclaré. (?0) ou (?R) permet de ré-invoquer le motif complet. L'exemple précédent peut se récrire :

  $re = qr{ (           # groupe #1
                        \(             # parenthèse ouvrante
                        (?:
                              (?> [^()]+ )    # groupe sans retour arrière
                          |
                              (?1)            # groupe avec parenthèses 
                        )*
                        \)             # parenthèse fermante
                      )
                  }x;

Ce qui est un peu plus clair, et permet de rester entièrement dans le moteur. Bien sûr essayer d'invoquer un groupe qui n'existe pas provoque une erreur fatale.

Plus intéressant, on peut invoquer un groupe nommé en utilisant la syntaxe (?&name). La syntaxe Python (?P>name) est aussi supportée.

On dispose aussi d'une construction conditionnelle (?(condition)yes-pattern|no-pattern) qui accepte les conditions possibles suivantes :

un numéro de groupe (1), (2)... pour tester si le groupe de ce numéro a capturé quelque chose ;
un nom de groupe <name> ou 'name' pour tester si le groupe de ce nom a capturé quelque chose ;
un bout de code Perl (?{ CODE }), qui est traité comme la condition ;
le symbole (R) pour tester si l'expression a été évaluée au sein d'une récursion ; il peut être suivi du numéro d'un groupe ((R1), (R2)..) ou du nom d'un groupe ((R&name)) pour tester si l'expression a été évaluée pendant l'exécution du groupe en question ; à noter que cela ne regarde que le niveau juste au-dessus ;
(DEFINE) est un cas un peu particulier, car seule la partie yes-pattern est autorisée, mais elle n'est jamais directement exécutée. On peut par contre entrer en récursion dans les sous-motifs qu'elle contient. En leur donnant un nom par la syntaxe usuelle, cela permet donc de définir des genres de fonctions de motifs, que l'on peut « cacher » dans un coin mais qu'on peut librement invoquer. Par exemple :
```
    m{
            (?<src_addr>(?&ip_addr))    # adresse IP source
            \s+ -> \s+
            (?<dest_addr>(?&ip_addr))   # adresse IP destination

            (?(DEFINE)
                    (?<ip_addr>...)     # motif pour reconnaître une 
            )                       # addresse IP
    }x
```
Un groupe de capture défini au sein d'un (?(DEFINE)..) n'est pas accessible au retour de la récursion, raison pour laquelle on doit inclure son invocation au sein d'un autre groupe capturant.

Nouvelle assertion Keep

Proposée et testée par Jeff Pinyan dans son module Regexp::Keep, l'assertion \K (pour Keep), permet d'effectuer des recherches et remplacements sans que la partie à gauche de \K ne soit touchée. C'est donc un genre d'assertion de présence arrière (positive look-behind assertion) autorisant un motif de longueur variable, mais de manière bien plus efficace.

Cela a typiquement été conçu pour pouvoir récrire des constructions comme s/(save)delete/$1/ en s/save\Kdelete//. L'expression utilisant \K est plus rapide que celle utilisant la capture car on évite l'allocation des structures de gestion des buffers. Techniquement, cela fonctionne en modifiant le pointeur PL_regstartp (qui est derrière les variables $& ou ${^MATCH}) pour qu'il pointe vers l'endroit courant de la chaîne où se situe \K une fois que la partie gauche a correspondu. Cette astuce permet mine de rien de diviser par deux le temps d'exécution.

Le module Regexp::Keep, disponible sur le CPAN, autorise les mêmes gains et fonctionne sur Perl 5.6 et 5.8.

Perl 6 dispose d'assertions similaires, <( qui est équivalente à \K pour le début de la chaîne, et )> qui est son pendant en fin de chaîne.

Nouvelles classes de caractères

Quelques nouvelles classes de caractères ont été ajoutées, toutes liées à différents types d'espaces :

\v correspond à une espace verticale, et \V à l'inverse.
\h correspond à une espace horizontale, et \H à l'inverse.
\R correspond à un saut de ligne, y compris le saut de ligne réseau CRLF ; plus précisément, cette classe est exactement équivalente à (?>\x0D\x0A?|[\x0A-\x0C\x85\x{2028}\x{2029}]) (mais en bien plus facile à taper et à comprendre).

Les nouveautés de Perl 5.10 - deuxième partie

Chapeau

Expressions régulières

Syntaxe et sémantique

Nouveaux quantifieurs

Nouveaux verbes

Captures

Motifs récursifs

Nouvelle assertion Keep

Nouvelles classes de caractères

Changements internes

Dérécursion du moteur

Optimisations

Classes de caractères

Trie

Aho-Corasick

En pratique

Moteur modulaire

Débuggage lexical

Plus d'informations

Conclusion

Auteur