Introduction

Qu’est-ce qu’une expression régulière ?

Une expression régulière (traduction de l’anglais regular expression), également appelée expression rationnelle, est une chaîne de caractères servant à décrire de façon générique un ensemble de chaînes grâce à l’utilisation de caractères ayant une signification particulière. Elle est parfois aussi appelée "modèle" (traduction de l’anglais pattern).

La syntaxe utilisée pour l’écriture des expressions régulières, conçue par Ken Thompson, est dérivée de la notation utilisée par le mathématicien Stephen Kleene, qui est à l’origine du concept.

De nombreux programmes sont capables d’interpréter des expressions régulières, avec pour objectif :

Les expressions régulières sont constituées de caractères sans signification, utilisés tels quels, et de caractères ayant une signification particulière pour le programme qui va les interpréter, et donnant lieu à un traitement spécifique.

Les caractères ayant une signification particulière sont...

Origine des expressions régulières

Les expressions régulières trouvent leur origine dans les travaux du mathématicien Stephen Cole Kleene, qui s’est d’abord intéressé aux fonctions récursives (ainsi qu’on peut le voir dans l’un de ses articles datant du 7 juillet 1935 : General recursive functions of natural numbers), puis ensuite aux langages réguliers (comme on peut le voir dans son document Representation of events in nerve nets and finite automata, du 15 décembre 1951). Les travaux de Kleene ont, entre autres, engendré la fameuse étoile de Kleene (*), utilisée dans la théorie des grammaires et des langages formels. Cette étoile, également appelée fermeture transitive de Kleene, ou plus simplement fermeture de Kleene, est utilisée pour indiquer un facteur de répétition (éventuellement nul) de l’élément auquel elle s’applique. On la retrouve souvent avec cette signification dans les différentes implémentations des expressions régulières.

C’est avec les travaux de Kenneth Lane Thompson (connu sous le nom Ken Thompson), l’un des principaux concepteurs du système d’exploitation UNIX, que les expressions régulières font pour la première fois leur apparition dans un logiciel.

Ken Thompson réalisa, vers la fin des années 1960, une nouvelle version (écrite en assembleur IBM 7090) de l’éditeur QED, et y intégra le concept d’expressions régulières, alors entièrement nouveau pour un éditeur de texte. Il inventa à cette occasion une manière originale de les traiter en utilisant une compilation à la volée, et déposa le 9 août 1967 un brevet qui fut publié le 2 mars 1971 sous le numéro 3.568.156 (US Patent 3,568,156, Text Matching Algorithm). 

Le manuel de QED datant du 22 juin 1970 (QED Text Editor, Case 70 107-002), écrit par Dennis Ritchie et Ken Thompson, décrit en pages 3 et 4 les expressions régulières telles qu’on les retrouve dans l’éditeur ed.

Les premières expressions régulières qui ont été implémentées étaient ce que l’on appelle de nos jours des expressions régulières basiques. Elles ont ensuite évolué pour donner naissance à un autre type d’expressions régulières, appelées expressions régulières étendues.

Les expressions régulières sont maintenant très répandues : on les trouve par exemple dans de nombreuses commandes UNIX (et dans les systèmes dérivés d’UNIX : Sun OS, Xenix, HP-UX, Solaris, AIX, Linux...), dans des langages de programmation, des outils de filtrages de messages électroniques, des fichiers de configurations, etc.

Quant au nom que l’on doit attribuer à ces expressions, les avis divergent, tout du moins en ce qui concerne leur appellation en français. Faut-il les appeler expressions régulières ou expressions rationnelles ? Les termes expressions régulières font référence aux travaux du mathématicien américain Stephen Kleene sur les langages réguliers, tandis que les termes expressions rationnelles font référence...

Conseil important pour la qualité et la fiabilité du code

Afin d’écrire des programmes ou des scripts fiables, il est nécessaire de faire en sorte qu’ils fonctionnent quelles que soient les conditions. En particulier, les arguments qu’ils recevront devront toujours respecter la syntaxe imposée par ces scripts ou programmes.

Les problèmes rencontrés lorsqu’on analyse des dysfonctionnements, des erreurs, ou des piratages, sont parfois dus à des syntaxes trop laxistes, et mal maîtrisées, entraînant des interprétations non souhaitées, comme par exemple :

Il est très important, pour écrire du code ou des commandes de qualité, de ne pas laisser de possibilité d’interprétation...

Programme d’aide à la compréhension du shell

Le shell interprète les commandes tapées au clavier ou passées dans un fichier ou via un tube de communication (pipe) et effectue parfois des traitements sur les arguments avant d’exécuter les actions (par exemple dans le cas d’évaluation de variables ou d’expressions régulières).

Il est primordial, si l’on veut éviter les erreurs d’interprétation, de fournir au shell des commandes qui fonctionnent dans tous les cas. La compréhension des mécanismes d’évaluation et de passage des paramètres est indispensable à l’écriture de commandes fiables. En particulier la signification des quotes (simples et doubles) doit être comprise et maîtrisée, afin qu’elles puissent être utilisées correctement.

Le programme args.c, donné en annexe, permet de visualiser les arguments tels qu’un programme les recevra. Il est très utile pour permettre la visualisation d’une syntaxe allégée, notamment dans le cas où une complexité entraîne une écriture relativement illisible, comme par exemple pour ce programme AWK :

awk 'function s2d(s) {  
     str_s         = sprintf("%d", s);  
     cmd   = "date -d '"'"'@" str_s "'"'"' '"'"'+%Y-%m-%d %H:%M:%S'"'"'"; 
     cmd | getline;  
     close(cmd);  
     return $0;  
}  
{  
     if ($0 ~ /^#/) {  
            sub(/^#/, "");  
            printf("%s\n", s2d($0));  
     }  
     else  
     {      print;  
            printf("\n");  
     }  
}' "$1" 

Les suites de quotes ’"’"’ sont difficiles à comprendre à la première lecture. Le fait que les quotes, simples ou doubles, soient utilisées à la fois pour introduire une chaîne et pour la terminer peut induire des confusions dans l’interprétation des arguments. Pour mieux les comprendre, il faut associer les quotes par paires en leur attribuant leur signification : une quote ouvrante et une quote fermante. Lorsqu’elles sont sur la même ligne et séparées seulement de quelques caractères, l’association visuelle se fait presque instantanément, mais lorsqu’elles sont séparées de plusieurs lignes comme ce peut être le cas dans un programme AWK, les associer devient moins évident. De plus, l’exécution d’un programme par le shell plutôt que par un appel direct depuis un autre programme (avec les fonctions execl(), execv(), ou leurs dérivées) alourdit la syntaxe en nécessitant l’ajout de caractères de protection supplémentaires (quotes ou antislashes), et rend les commandes plus difficiles à lire et donc à comprendre.

Le programme args affiche les arguments tels qu’il les a reçus du shell, après substitution des métacaractères et suppression des caractères qui lui étaient spécifiquement destinés. Cela permet, grâce à une simplification de l’écriture, de mieux visualiser les caractères et leur fonction, et donc de mieux comprendre la signification des expressions compliquées.

Si l’on passe la commande AWK du script ci-dessus au programme args, il affichera les arguments suivants :

ARGC = 4  
ARGV[  1 : length =   3] = "awk"  
ARGV[  2 : length = 244] = "function s2d(s) {  
     str_s = sprintf("%d", s);  
     cmd   = "date -d '@" str_s "' '+%Y-%m-%d %H:%M:%S'";  
     cmd | getline;  
     close(cmd);  
     return $0;  
}  
{  
     if ($0 ~ /^#/) {  
           sub(/^#/, "");  
           printf("%s\n", s2d($0));  
     }...