TREGEXPR DOCUMENTATION - VERSION 1.147 ANDREY SOROKIN

La page est créée Fabienne Laporte
 
CONTINUER À LIRE
TRegExpr Documentation
              Version 1.147

            Andrey Sorokin

                  mai 04, 2022
Table des matières

1   Avis                                                                                                                                                                                         3

2   Démarrage rapide                                                                                                                                                                             5

3   Retour d’information                                                                                                                                                                         7

4   Code source                                                                                                                                                                                  9

5   Documentation                                                                                                                                                                               11
    5.1 Expressions régulières (RegEx)      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   11
    5.2 TRegExpr . . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   21
    5.3 FAQ . . . . . . . . . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   29
    5.4 Démos . . . . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   32

6   Traductions                                                                                                                                                                                 35

7   Reconnaissance                                                                                                                                                                              37

                                                                                                                                                                                                 i
ii
TRegExpr Documentation, Version 1.147

                                                   English                  Deutsch                 Français     Español

La bibliothèque TRegExpr implémente des expressions régulières ‘_.
Les expressions régulières sont un outil puissant et facile à utiliser pour la recherche et la substitution sophistiquées et
pour la vérification de texte basée sur des modèles.
Il est particulièrement utile pour la validation des entrées utilisateur dans les formulaires de saisie - pour valider les
adresses électroniques, etc.
Vous pouvez également extraire des numéros de téléphone, codes postaux, etc. à partir de pages Web ou de documents,
rechercher des modèles complexes dans des fichiers journaux et tout ce que vous pouvez imaginer. Les règles (modèles)
peuvent être modifiées sans la recompilation de votre programme.
TRegExpr est implémenté en Pascal pur. Il est inclus dans Lazarus (Free Pascal) projet. Mais il existe aussi en tant que
bibliothèque séparée et peut être compilé par Delphi 2-7, Borland C ++ Builder 3-6.

Table des matières                                                                                                         1
TRegExpr Documentation, Version 1.147

2                                       Table des matières
CHAPITRE   1

                                                       Avis

Comment bien la bibliothèque a été rencontré.

                                                           3
TRegExpr Documentation, Version 1.147

4                                       Chapitre 1. Avis
CHAPITRE              2

                                                                                       Démarrage rapide

Pour utiliser la bibliothèque, ajoutez simplement les sources vous projetez et utilisez la classe‘ TRegExpr ‘_.
Dans la FAQ vous pouvez apprendre des problèmes des autres utilisateurs.
Prêt à exécuter l’application Windows REStudio vous aidera à apprendre et à déboguer les expressions régulières.

                                                                                                                   5
TRegExpr Documentation, Version 1.147

6                                       Chapitre 2. Démarrage rapide
CHAPITRE      3

                                                                                  Retour d’information

Si vous voyez des problèmes, veuillez créer le bogue. ‘_.

                                                                                                          7
TRegExpr Documentation, Version 1.147

8                                       Chapitre 3. Retour d’information
CHAPITRE   4

                                                           Code source

Pure Object Pascal.
   — Version originale
   — Fourche FreePascal (miroir GitHub de la SubVersion)

                                                                      9
TRegExpr Documentation, Version 1.147

10                                      Chapitre 4. Code source
CHAPITRE            5

                                                                                               Documentation

                                                 English                 Deutsch                 Français    Español

5.1 Expressions régulières (RegEx)

5.1.1 introduction

Les expressions régulières sont un moyen pratique de spécifier des modèles de texte.
Avec les expressions régulières, vous pouvez valider la saisie de l’utilisateur, rechercher des modèles tels que les
adresses électroniques de numéros de téléphone sur des pages Web ou dans certains documents, etc.
Below is the complete regular expressions cheat sheet.

5.1.2 Personnages

Matchs simples

Any single character (except special regex characters) matches itself. A series of (not special) characters matches that
series of characters in the input string.

                                               RegEx        Allumettes
                                               foobar       foobar

Caractères non imprimables (codes d’échappement)

To specify character by its Unicode code, use the prefix \x followed by the hex code. For 3-4 digits code (after
U+00FF), enclose the code into braces.

                                                                                                                     11
TRegExpr Documentation, Version 1.147

                              RegEx              Allumettes
                              \xAB               character with 2-digit hex code AB
                              \x{AB20}           character with 1..4-digit hex code AB20
                              ‘‘ foo x20bar‘‘    foo bar (notez l’espace au milieu)

There are a number of predefined escape-codes for non-printable characters, like in C language :

 RegEx                                                       Allumettes
 ‘‘ t‘‘                                                      onglet (HT / TAB), identique à \x09
 \n                                                          line feed (LF), same as \x0a
 ‘‘ r‘‘                                                      carriage return (CR), same as \x0d
 ‘‘ f‘‘                                                      Form Feed (FF), identique à ‘‘ x0c‘‘
 ‘‘ a‘‘                                                      alarme (BEL), identique à ‘‘ x07‘‘
 ‘‘ e‘‘                                                      échappement (ESC), identique à ‘‘ x1b‘‘
 \cA . . . \cZ
                                                             chr(0) to chr(25).
                                                             For example, \cI matches the tab-char.
                                                             Lower-case letters « a ». . . »z » are also supported.

S’échapper

To represent special regex character (one of .+*?|\()[]{}^$), prefix it with a backslash \. The literal backslash
must be escaped too.

                           RegEx                Allumettes
                           \^FooBarPtr          ^FooBarPtr, this is ^ and not start of line
                           ‘‘ [a ] ‘‘           [a], this is not character class

5.1.3 Classes de personnages

Classes de caractères utilisateur

Character class is a list of characters inside square brackets []. The class matches any single character listed in this
class.

                    RegEx                   Allumettes
                    ‘‘ foob [aeiou] r‘‘     foobar, foober etc mais pas foobbr, foobcr etc

You can « invert » the class - if the first character after the [ is ^, then the class matches any character except the
characters listed in the class.

                    RegEx                   Allumettes
                    ‘‘ foob [^ aeiou] r‘‘   foobbr, foobcr etc mais pas foobar, foober etc

Within a list, the dash - character is used to specify a range, so that a-z represents all characters between a and z,
inclusive.

12                                                                                     Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

If you want the dash - itself to be a member of a class, put it at the start or end of the list, or escape it with a backslash.
If you want ] as part of the class you may place it at the start of list or escape it with a backslash.

                                    RegEx            Allumettes
                                    [-az]            a, z et -
                                    [az-]            a, z et -
                                    ‘‘ [a -z] ‘‘     a, z et -
                                    ‘‘ [az] ‘‘       caractères de a à z
                                    ‘‘ [n- x0D] ‘‘   characters from chr(10) to chr(13)

Meta-Classes

There are a number of predefined character classes that keeps regular expressions more compact, « meta-classes » :

 RegEx                                                           Allumettes
 \w                                                              an alphanumeric character, including _
 \W                                                              a non-alphanumeric
 ‘‘ d‘‘                                                          a numeric character (same as [0-9])
 ‘‘ D‘‘                                                          un non numérique
 \s                                                              N’importe quel espace (identique à [\t\n\r\f])
 ‘‘ S‘‘                                                          a non-space
 \h
                                                                 horizontal whitespace : the tab and all characters
                                                                 in the « space separator » Unicode category

 \H                                                              not a horizontal whitespace
 \v
                                                                 vertical whitespace : all characters treated as
                                                                 line-breaks in the Unicode standard

 \V                                                              not a vertical whitespace

You may use all meta-classes, mentioned in the table above, within user character classes.

           RegEx               Allumettes
           ‘‘ foob dr‘‘        foob1r, foob6r and so on, but not foobar, foobbr and so on
           ‘‘ foob [w s] r‘‘   foobar, foob r, foobbr and so on, but not foob1r, foob=r and so on

Note : TRegExpr
Propriétés SpaceChars et‘ WordChars ‘_ définit les classes de caractères‘ w‘,‘ W‘,‘‘s‘‘, \S.
So you can redefine these classes.

5.1.4 Limites

5.1. Expressions régulières (RegEx)                                                                                        13
TRegExpr Documentation, Version 1.147

Limites de lignes

                          Meta-char      Allumettes
                          .              any character, can include line-breaks
                          ^              zero-length match at start of line
                          $              zero-length match at end of line
                          ‘‘ A‘‘         zero-length match at the very beginning
                          \z             zero-length match at the very end
                          ‘‘ Z‘‘         like \z but also matches before the final line-break

Examples :

                     RegEx              Allumettes
                     ‘‘ ^ foobar‘‘      foobar seulement si c’est en début de ligne
                     ‘‘ foobar $ ‘‘     foobar seulement si c’est en fin de ligne
                     ‘‘ ^ foobar $ ‘‘   foobar seulement s’il s’agit de la seule chaîne en ligne
                     ‘‘ foob.r‘‘        foobar, foobbr, foob1r et ainsi de suite

Meta-char ^ matches zero-length position at the beginning of the input string. $ - at the ending. If modifier /m is on,
they also match at the beginning/ending of individual lines in the multi-line text.
Notez qu’il n’y a pas de ligne vide dans la séquence ‘‘ x0D x0A‘‘.

Note : TRegExpr
Si vous utilisez la version Unicode ‘__, alors‘ ^ /‘‘$‘ correspond également à‘ x2028‘,‘
x2029‘,‘ x0B‘,‘ x0C‘ ou \x85.

Meta-char \A matches zero-length position at the very beginning of the input string, \z - at the very ending. They
ignore modifier /m. \Z is like \z but also matches before the final line-break (LF and CR LF). Behaviour of \A, \z,
\Z is made like in most of major regex engines (Perl, PCRE, etc).
Meta-char . (dot) by default matches any character, but if you turn off the modifier /s, then it won’t match line-breaks
inside the string.
Note that ^.*$ does not match a string between \x0D\x0A, because this is unbreakable line separator. But it matches
the empty string within the sequence \x0A\x0D because this is 2 line-breaks in the wrong order.

Note : TRegExpr
Multi-line processing can be tuned by properties LineSeparators and UseLinePairedBreak.
Vous pouvez donc utiliser les séparateurs de style Unix \n ou le style DOS / Windows \r\n ou les mélanger (comme
décrit dans le comportement par défaut ci-dessus).

Si vous préférez une description mathématiquement correcte, vous pouvez la trouver sur www.unicode.org.

Limites des mots

                                           RegEx      Allumettes
                                           \b         une limite de mot
                                           \B         une limite de non-mot

14                                                                                    Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

Une limite de mots \b est un espace entre deux caractères qui ont un ‘‘ w w‘‘ d’un côté et un \W de l’autre côté (dans
l’un ou l’autre ordre).

5.1.5 Quantification

Quantifiers

Tout élément d’une expression régulière peut être suivi d’un quantificateur. Le quantificateur spécifie le nombre de
répétitions de l’article.

                                  RegEx          Allumettes
                                  ‘‘ {n} ‘‘      exactement n fois
                                  ‘‘ {n,} ‘‘     au moins n fois
                                  ‘‘ {n, m} ‘‘   au moins n mais pas plus de m fois
                                  *              zéro ou plus, semblable à {0,}
                                  +              un ou plusieurs, similaire à {1,}
                                  ?              zéro ou un, similaire à {0,1}

Ainsi, les chiffres entre accolades ‘‘ {n, m} , spécifient le nombre minimum de fois où
correspondre ``n et le maximum m.
The {n} is equivalent to {n,n} and matches exactly n times. The {n,} matches n or more times.
There is no practical limit to the values n and m (limit is maximal signed 32-bit value).

                    RegEx                   Allumettes
                    ‘‘ foob. * r‘‘          foobar, foobalkjdflkj9r et foobr
                    ‘‘ foob. + r‘‘          foobar, foobalkjdflkj9r mais pas foobr
                    ‘‘ foob. ? r‘‘          foobar, foobbr et foobr mais pas foobalkj9r
                    ‘‘ fooba {2} r‘‘        foobaar
                    ‘‘ fooba {2,} r‘‘       foobaar, foobaaar, foobaaaar etc.
                    ‘‘ fooba {2,3} r‘‘      foobaar, ou foobaaar mais pas foobaaaar
                    ‘‘ (foobar) {8,10} ‘‘   8. . . 10 instances of foobar (() is group)

Cupidité

Quantifiers in « greedy » mode takes as many as possible, in « lazy » mode - as few as possible.
By default all quantifiers are « greedy ». Append the character ? to make any quantifier « lazy ».
Pour la chaîne abbbbc :

                                             RegEx             Allumettes
                                             ‘‘ b + ‘‘         bbbb
                                             b+?               b
                                             b*?               chaîne vide
                                             ‘‘ b {2,3} ? ‘‘   ‘‘ bb‘‘
                                             ‘‘ b {2,3} ‘‘     ‘‘ bbb‘‘

You can switch all quantifiers into « lazy » mode (modifier /g, below we use in-line modifier change).

5.1. Expressions régulières (RegEx)                                                                                15
TRegExpr Documentation, Version 1.147

                                              RegEx                 Allumettes
                                              ‘‘ ( ? -g) b + ‘‘     b

Possessive Quantifier

The syntax is : a++, a*+, a?+, a{2,4}+. Currently it’s supported only for simple braces, but not for braces after
group like (foo|bar){3,5}+.
This regex feature is described here. In short, possessive quantifier speeds up matching in complex cases.

5.1.6 Choice

Expressions in the choice are separated by vertical bar |.
Donc ‘‘ fee | fie | foe‘‘ correspondra à l’un des fee, fie ou foe dans la chaîne cible (comme le ferait ‘‘ f (e | i | o) e
‘‘).
La première expression inclut tout du dernier délimiteur de motif (‘‘ (, `` `` ``, ou le début du
motif) jusqu'au premier ``|, et la dernière expression contient tout du dernier | vers le prochain
délimiteur de motif.
Cela semble un peu compliqué, il est donc courant d’inclure le choix entre parenthèses afin d’éviter toute confusion
quant au début et à la fin.
Les expressions dans le choix sont essayées de gauche à droite, ainsi la première expression qui correspond est celle
qui est choisie.
Par exemple, l’expression régulière ’foo | foot‘ dans la chaîne‘ barefoot‘ correspond à‘’ foo‘‘. Juste une première
expression qui correspond.
Rappelez-vous également que | est interprété comme un littéral entre crochets, donc si vous écrivez [[fee | fie | foe]
vous ne faites en fait que correspondre à [feio |] ‘.

                                      RegEx                       Allumettes
                                      ‘‘ foo (bar | foo) ‘‘       foobar ou foofoo

5.1.7 Groups

The brackets () are used to define groups (ie subexpressions).

Note : TRegExpr
Group positions, lengths and actual values will be in MatchPos, MatchLen and Match.
Vous pouvez les remplacer par Substitute.

Groups are numbered from left to right by their opening parenthesis (including nested groups). First group has index
1. The entire regex has index 0.
      For string foobar, the regex (foo(bar)) will find :

                                                   Group          Value
                                                   0              foobar
                                                   1              foobar
                                                   2              bar

16                                                                                      Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

5.1.8 Références arrières

Meta-chars \1 through \9 are interpreted as backreferences to groups. They match the previously found group with
the specified index.

                                         RegEx         Allumettes
                                         (.)\1+        aaaa et cc
                                         (.+)\1+       aussi abab et 123123

RegEx (['"]?)(\d+)\1 matches "13" (in double quotes), or '4' (in single quotes) or 77 (without quotes) etc.

5.1.9 Named Groups and Backreferences

To make some group named, use this syntax : (?Pexpr). Also Perl syntax is supported : (?'name'expr).
Name of group must be valid identifier : first char is letter or « _ », other chars are alphanumeric or « _ ». All named
groups are also usual groups and share the same numbers 1 to 9.
Backreferences to named groups are (?P=name), the numbers \1 to \9 can also be used.

                               RegEx                               Allumettes
                               (?P['"])\w+(?P=qq)              "word" and 'word'

5.1.10 Modificateurs

Les modificateurs permettent de modifier le comportement des expressions régulières.
You can set modifiers globally in your system or change inside the regular expression using the ( ?imsxr-imsxr).

Note : TRegExpr
Pour changer les modificateurs, utilisez ModifierStr ou les propriétés TRegExpr` appropriées‘ Modifier * ‘__.
Les valeurs par défaut sont définies dans variables globales. Par exemple, la variable globale RegExprModifierX
définit la valeur par défaut de la propriété ModifierX.

je, insensible à la casse

Insensible à la casse. Utilisez installé dans les paramètres régionaux de votre système, voir aussi InvertCase.

m, chaînes multi-lignes

Traiter la chaîne comme plusieurs lignes. Donc ‘‘ ‘‘ et‘‘$‘ correspondent au début ou à la fin de n’importe quelle ligne
n’importe où dans la chaîne.
Voir aussi Limites de ligne.

5.1. Expressions régulières (RegEx)                                                                                  17
TRegExpr Documentation, Version 1.147

s, chaînes simples

Traiter la chaîne comme une seule ligne. Donc . correspond à n’importe quel caractère, même à un séparateur de
ligne.
Voir aussi Limites de ligne, auquel elle ne correspond normalement pas.

g, la gourmandise

Note : TRegExpr seul modificateur.

En le sélectionnant Off, vous basculerez les quantificateurs ‘__ en mode‘ non glouton ‘__.
Donc, si le modificateur «/ g» est «désactivé», alors «+» fonctionne comme «+ ?», «*» Comme «* ?» Et ainsi de suite.
Par défaut, ce modificateur est On.

x, syntaxe eXtended

Permet de commenter une expression régulière et de la diviser en plusieurs lignes.
Si le modificateur est ‘‘ On‘‘, nous ignorons tous les espaces qui ne sont ni antislash ni dans une classe de caractères.
Et le caractère # sépare les commentaires.
Notez que vous pouvez utiliser des lignes vides pour mettre en forme une expression régulière pour une meilleure
lisibilité :

((abc) # comment 1 # (efg) # comment 2)

Cela signifie également que si vous voulez de vrais espaces ou des caractères # dans le motif (en dehors d’une classe
de caractères, où ils ne sont pas affectés par / x‘), vous devrez soit les échapper soit les encoder en utilisant échappées
octales ou hexagonales.

r, gammes russes

Note : TRegExpr seul modificateur.

En russe, les caractères de la table ASCII ‘‘ ‘‘ / sont placés séparément des autres.
Grands et petits caractères russes sont dans des plages séparées, c’est la même chose que pour les caractères anglais
mais néanmoins je voulais une forme abrégée.
Avec ce modificateur à la place de [--] vous pouvez écrire [-] ‘‘ si vous avez besoin de tous les caractères russes.
Lorsque le modificateur est ‘‘ On‘‘ :

                                           RegEx      Allumettes
                                           ‘‘ -‘‘     caractères de à et ‘‘ ‘‘
                                           ‘‘ -‘‘     caractères de à et ‘‘ ‘‘
                                           ‘‘ -‘‘     tous les symboles russes

Le modificateur est défini par défaut sur On.

18                                                                                      Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

5.1.11 Assertions

Positive lookahead assertion : foo(?=bar) matches « foo » only before « bar », and « bar » is excluded from the
match.
Negative lookahead assertion : foo(?!bar) matches « foo » only if it’s not followed by « bar ».
Positive lookbehind assertion : (?
TRegExpr Documentation, Version 1.147

           RegEx                                     Allumettes
           ‘‘ ( ? i) Saint-Petersburg‘‘              «Saint-Pétersbourg» et «Saint-Pétersbourg»
           ‘‘ ( ? i) Saint - ( ? - i) Petersburg‘‘   ‘‘ Saint-Petersburg‘‘ mais pas ‘‘ Saint-petersburg‘‘
           ‘‘ ( ? i) (Saint -) ? Petersburg‘‘        ‘‘ Saint-petersburg‘‘ et saint-petersburg
           ‘‘ (( ? i) Saint -) ? Petersburg‘‘        saint-Petersburg, mais pas saint-petersburg

5.1.15 Comments

Syntax is like this : (?#text). Text inside brackets is ignored.
Notez que le commentaire est fermé par le ) le plus proche, il n’ya donc aucun moyen de mettre un littéral ) dans le
commentaire.

5.1.16 Recursion

Syntax is (?R), the alias is (?0).
The regex a(?R)?z matches one or more letters « a » followed by exactly the same number of letters « z ».
The main purpose of recursion is to match balanced constructs or nested constructs. The generic regex is b(?:m|(?
R))*e where « b » is what begins the construct, « m » is what can occur in the middle of the construct, and « e » is
what occurs at the end of the construct.
If what may appear in the middle of the balanced construct may also appear on its own without the beginning and
ending parts then the generic regex is b(?R)*e|m.

5.1.17 Subroutine calls

Syntax for call to numbered groups : (?1) . . . (?90) (maximal index is limited by code).
Syntax for call to named groups : (?P>name). Also Perl syntax is supported : (?&name).
This is like recursion but calls only code of capturing group with specified index.

5.1.18 Unicode Categories

Unicode standard has names for character categories. These are 2-letter strings. For example « Lu » is uppercase
letters, « Ll » is lowercase letters. And 1-letter bigger category « L » is all letters.
     — Cc - Control
     — Cf - Format
     — Co - Private Use
     — Cs - Surrrogate
     — Ll - Lowercase Letter
     — Lm - Modifier Letter
     — Lo - Other Letter
     — Lt - Titlecase Letter
     — Lu - Uppercase Letter
     — Mc - Spacing Mark
     — Me - Enclosing Mark
     — Mn - Nonspacing Mark
     — Nd - Decimal Number
     — Nl - Letter Number

20                                                                                    Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

   — No - Other Number
   — Pc - Connector Punctuation
   — Pd - Dash Punctuation
   — Pe - Close Punctuation
   — Pf - Final Punctuation
   — Pi - Initial Punctuation
   — Po - Other Punctuation
   — Ps - Open Punctuation
   — Sc - Currency Symbol
   — Sk - Modifier Symbol
   — Sm - Math Symbol
   — So - Other Symbol
   — Zl - Line Separator
   — Zp - Paragraph Separator
   — Zs - Space Separator
Meta-character \p denotes one Unicode char of specified category. Syntaxes : \pL and \p{L} for 1-letter name,
\p{Lu} for 2-letter names.
Meta-character \P is inverted, it denotes one Unicode char not in the specified category.
These meta-characters are supported withing character classes too.

5.1.19 Épilogue

Dans cet ancien billet de blog du siècle précédent J’illustre quelques utilisations d’expressions régulières.

                                                  Anglais                 Deutsch                 Français      Español

5.2 TRegExpr

Implements regular expressions in pure Pascal. Compatible with Free Pascal, Delphi 2-7, C++Builder 3-6.
To use it, copy files « regexpr.pas », « regexpr_unicodedata.pas », « regexpr_compilers.inc », to your project folder.
The library is already included into Lazarus (Free Pascal) project so you do not need to copy anything if you use
Lazarus.

5.2.1 Classe TRegExpr

VersionMajor, VersionMinor

Return major and minor version of the component.
VersionMajor = 1
VersionMinor = 101

Expression

Expression régulière.
For optimization, regular expression is automatically compiled into P-code. Human-readable form of the P-code is
returned by Dump.

5.2. TRegExpr                                                                                                         21
TRegExpr Documentation, Version 1.147

In case of any errors in compilation, Error method is called (by default Error raises exception ERegExpr).

ModifierStr

Définir ou obtenir les valeurs de modificateurs d’expression régulière.
Format of the string is similar to (?ismx-ismx). For example ModifierStr := ‘i-x’ will switch on the modifier
/i, switch off /x and leave unchanged others.
Si vous essayez de définir un modificateur non supporté, Error sera appelé.

Modificateur

Modifier /i, « case-insensitive », initialized with RegExprModifierI value.

Modificateur

Modificateur / r," extension de la plage russe ", initialisé avec la valeur RegExprModifierR.

Modificateurs

Modificateur / s," chaînes simples ", initialisé avec la valeur RegExprModifierS.

Modificateur

Modificateur / g," gourmandise ", initialisé avec la valeur RegExprModifierG.

Modificateur

Modificateur / m," chaînes multilignes ", initialisé avec la valeur RegExprModifierM.

ModificateurX

Modificateur / x," syntaxe eXtended ", initialisé avec la valeur RegExprModifierX.

Exec

Finds regular expression against AInputString, starting from the beginning.
The overloaded Exec version without AInputString exists, it uses AInputString from previous call.
Voir aussi la fonction globale ExecRegExpr que vous pouvez utiliser sans la création explicite d’objet TRegExpr.

ExecNext

Finds next match. If parameter ABackward is True, it goes downto position 1, ie runs backward search.
Without parameter it works the same as :

22                                                                                   Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

si MatchLen [0] = 0 alors ExecPos (MatchPos [0] + 1) sinon ExecPos (MatchPos [0] +
 ˓→MatchLen [0]);

Lève une exception si elle est utilisée sans précéder l’appel réussi à Exec, ExecPos ou ExecNext.
So you always must use something like :

if Exec(InputString)
  then
    repeat
      { proceed results}
    until not ExecNext;

ExecPos

Finds match for AInputString starting from AOffset position (1-based).
Parameter ABackward means going from AOffset downto 1, ie backward search.
Parameter ATryOnce means that testing for regex will be only at the initial position, without going to next/previous
positions.

InputString

Renvoie la chaîne d’entrée en cours (à partir du dernier appel Exec ou de la dernière affectation à cette propriété).
Toute affectation à cette propriété efface Match, MatchPos et MatchLen.

Remplacer

fonction Substitute (const ATemplate: RegExprString): RegExprString;

Returns ATemplate, where $& or $0 are replaced with the found match, and $1 to $9 are replaced with found
groups 1 to 9.
To use in template the characters $ or \, escape them with a backslash \, like \\ or \$.

                                  Symbol      Description
                                  $&          match entier expression régulière
                                  $0          match entier expression régulière
                                  $1 .. $9    contents of numbered group 1 .. 9
                                  \n          dans Windows remplacé par \r\n
                                  \l          lowercase one next char
                                  \L          minuscule tous les caractères après cela
                                  \u          uppercase one next char
                                  \U          majuscule tous les caractères après cela

'1 \ $ est $ 2 \\ rub \\' -> '1 $ est  \ rub \ '' \
 ˓→U $ 1 \\ r 'se transforme en'  \ r '

Si vous voulez placer un chiffre brut après ’$ n’, vous devez délimiter n avec des accolades ‘‘ {} ‘‘.

5.2. TRegExpr                                                                                                           23
TRegExpr Documentation, Version 1.147

'a $ 12bc' -> 'a  bc '' a $ {1} 2bc '->'
 ˓→a  2bc '.

To use found named groups, use syntax ${name}, where « name » is valid identifier of previously found named group
(starting with non-digit).

Divisé

Splits AInputStr into APieces by regex occurrences.
Appelle en interne Exec / ExecNext
Voir aussi la fonction globale SplitRegExpr que vous pouvez utiliser sans la création explicite d’objet TRegExpr.

Remplacer, RemplacerEx

fonction Remplacer (Const AInputStr: RegExprString; const AReplaceStr: RegExprString;
 ˓→AUseSubstitution: boolean = False): RegExprString; surcharge; function Remplacer

 ˓→(Const AInputStr: RegExprString; AReplaceFunc: TRegExprReplaceFunction):

 ˓→RegExprString; surcharge; function ReplaceEx (Const AInputStr: RegExprString;

 ˓→AReplaceFunc: TRegExprReplaceFunction): RegExprString;

Returns the string with regex occurencies replaced by the replace string.
Si le dernier argument (AUseSubstitution) est vrai, alors AReplaceStr sera utilisé comme modèle pour les
méthodes de substitution.
Expression: = '((? I) bloc | var) \ s * (\ s * \ ([^] * \) \ s *) \ s *';
 ˓→Remplacez ('BLOCK (test1)', 'def "$ 1" valeur "$ 2"&

 ˓→#39;, True);

Retourne def "BLOCK" valeur "test1"
Remplacez ('BLOCK (test1)', 'def "$ 1", valeur "$ 2"&
 ˓→#39;, False)

Retourne ‘‘ def &quot ;$ 1&quot ; valeur &quot ;$ 2&quot ; ‘‘
Appelle en interne Exec / ExecNext
Overloaded version and ReplaceEx operate with callback function, so you can implement really complex functio-
nality.
Voir aussi la fonction globale ReplaceRegExpr que vous pouvez utiliser sans la création explicite d’objet TRegExpr.

SubExprMatchCount

Count of groups (subexpressions) found in last Exec / ExecNext call.
If there are no groups found, but some string was found (Exec* returned True), it returns 0. If no groups nor some
string were found (Exec / ExecNext returned false), it returns -1.
Note, that some group may be not found, and for such group MathPos=MatchLen=-1 and Match=”.
Expression: = '(1)? 2 (3)?'; Exec ('123'): SubExprMatchCount = 2,
 ˓→Match [0] = '123', [1] = '1', [2] = '3' Exec ('12'

 ˓→): SubExprMatchCount = 1, Match [0] = '12 ', [1] =' 1 'Exec ('
                                                                        (suite sur la page suivante)
 ˓→23 '): SubExprMatchCount = 2, Match [0] =' 23 ', [1] =' ', [2]

 ˓→=' 3 'Exec (' 2 '): SubExprMatchCount = 0, Match [0] =' 2 '

 ˓→Exec (' 7 ') - renvoie False: SubExprMatchCount = -1
24                                                                                 Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

                                                                                                (suite de la page précédente)

MatchPos

Position (1-based) of group with specified index. Result is valid only after some match was found. First group has
index 1, the entire match has index 0.
Returns -1 if no group with specified index was found.

MatchLen

Length of group with specified index. Result is valid only after some match was found. First group has index 1, the
entire match has index 0.
Returns -1 if no group with specified index was found.

Rencontre

String of group with specified index. First group has index 1, the entire match has index 0. Returns empty string, if no
such group was found.

MatchIndexFromName

Returns group index (1-based) from group name, which is needed for « named groups ». Returns -1 if no such named
group was found.

LastError

Returns Id of last error, or 0 if no errors occured (unusable if Error method raises exception). It also clears internal
status to 0 (no errors).

ErrorMsg

Renvoie le message Error en cas d’erreur avec ‘‘ ID = AErrorID‘‘.

CompilerErrorPos

Returns position in regex, where P-code compilation was stopped.
Useful for error diagnostics.

SpaceChars

Contains chars, treated as \s (initially filled with RegExprSpaceChars global constant).

WordChars

Contains chars, treated as \w (initially filled with RegExprWordChars global constant).

5.2. TRegExpr                                                                                                            25
TRegExpr Documentation, Version 1.147

LineSeparators

Line separators (like \n in Unix), initially filled with RegExprLineSeparators global constant).
See also Line Boundaries

UseLinePairedBreak

Boolean property, enables to detect paired line separator CR LF.
See also Line Boundaries
For example, if you need only Unix-style separator LF, assign LineSeparators := #$a and
UseLinePairedBreak := False.
If you want to accept as line separators only CR LF but not CR or LF alone, then assign LineSeparators := ''
(empty string) and UseLinePairedBreak := True.
By default, « mixed » mode is used (defined in RegExprLineSeparators global constant) :

LineSeparators := #$d#$a;
UseLinePairedBreak := True;

Behaviour of this mode is described in the Line Boundaries.

Compiler

Compiles regular expression to internal P-code.
Utile par exemple pour les éditeurs d’expressions régulières GUI - pour vérifier les expressions régulières sans les
utiliser.

Déverser

Shows P-code (compiled regular expression) as human-readable string.

5.2.2 Constantes globales

EscChar

Escape character, by default backslash '\'.

SubstituteGroupChar

Char used to prefix groups (numbered and named) in Substitute method, by default '$'.

RegExprModifierI

Modifier i default value.

26                                                                                   Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

RegExprModifierR

Modifier r default value.

RegExprModifierS

Modifier s default value.

RegExprModifierG

Modifier g default value.

RegExprModifierM

Modifier m default value.

RegExprModifierX

Modifier x default value.

RegExprSpaceChars

Default for SpaceChars property.

RegExprWordChars

Default value for WordChars property.

RegExprLineSeparators

Default value for LineSeparators property.

5.2.3 Fonctions globales

Toutes ces fonctionnalités sont disponibles en tant que méthodes de TRegExpr, mais avec les fonctions globales, il
n’est pas nécessaire de créer une instance TReExpr pour que votre code soit plus simple si vous n’avez besoin que
d’une seule fonction.

ExecRegExpr

Returns True if the string matches the regular expression. Just like Exec in TRegExpr.

SplitRegExpr

Splits the string by regular expression occurences. See also Split if you prefer to create TRegExpr instance explicitly.

5.2. TRegExpr                                                                                                        27
TRegExpr Documentation, Version 1.147

ReplaceRegExpr

function ReplaceRegExpr (const ARegExpr, AInputStr, AReplaceStr: RegExprString;
 ˓→AUseSubstitution: boolean = False): RegExprString; surcharge; Type

 ˓→TRegexReplaceOption = (rroModifierI, rroModifierR, rroModifierS, rroModifierG,

 ˓→rroModifierM, rroModifierX, rroUseSubstitution, rroUseOsLineEnd);

 ˓→TRegexReplaceOptions = Ensemble de TRegexReplaceOption; fonction ReplaceRegExpr

 ˓→(const ARegExpr, AInputStr, AReplaceStr: RegExprString; Options:

 ˓→TRegexReplaceOptions): RegExprString; surcharge;

Retourne la chaîne avec les expressions régulières remplacées par le AReplaceStr. Voir aussi Replace si vous
préférez créer explicitement l’instance de TRegExpr.
If last argument (AUseSubstitution) is True, then AReplaceStr will be used as template for Substitution
methods :

ReplaceRegExpr ('((? I) bloc | var) \ s * (\ s * \ ([^] * \) \ s *) \ s *', &
 ˓→#39;BLOCK (test1)', 'def "$ 1" valeur " 2 $ '', True)

Returns def 'BLOCK' value 'test1'
Mais celui-ci (notez qu’il n’y a pas de dernier argument) :

ReplaceRegExpr ('((? I) bloc | var) \ s * (\ s * \ ([^] * \) \ s *) \ s *', &
 ˓→#39;BLOCK (test1)', 'def "$ 1" valeur " 2 $ ''

Retourne ‘‘ def &quot ;$ 1&quot ; valeur &quot ;$ 2&quot ; ‘‘

Version avec options

Avec Options vous contrôlez le comportement du \n (si rroUseOsLineEnd alors \n est remplacé par \n\r
sous Windows et \n dans Linux). Etc.

Type TRegexReplaceOption = (rroModifierI, rroModifierR, rroModifierS, rroModifierG,
 ˓→rroModifierM, rroModifierX, rroUseSubstitution, rroUseOsLineEnd);

QuoteRegExprMetaChars

Replace all metachars with its safe representation, for example abc'cd.( is converted to abc\'cd\.\(
This function is useful for regex auto-generation from user input.

RegExprSubExpressions

Makes list of subexpressions found in ARegExpr.
In ASubExps every item represents subexpression, from first to last, in format :
String - texte de sous-expression (sans ’()’)
Low word of Object - starting position in ARegExpr, including ‘(’ if exists ! (first position is 1)
High word of Object - length, including starting ‘(’ and ending ‘)’ if exist !
AExtendedSyntax - must be True if modifier /x os on, while using the regex.
Usefull for GUI editors of regex (you can find example of usage in REStudioMain.pas)

28                                                                                      Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

         Code de résultat      Sens
         0                     Success. No unbalanced brackets were found.
         -1                    Not enough closing brackets ).
         -(n+1)                At position n it was found opening [ without corresponding closing ].
         n                     At position n it was found closing bracket ) without corresponding opening (.

If Result  0, then ASubExprs can contain empty items or illegal ones.

5.2.4 ERegExpr

ERegExpr = class (Exception) public ErrorCode: integer; // code d'erreur. Les
 ˓→codes d'erreur de compilation sont avant 1000 CompilerErrorPos: integer; //

 ˓→Position dans le lieu où l'erreur de compilation s'est produite end;

5.2.5 Unicode

In Unicode mode, all strings (InputString, Expression, internal strings) are of type UnicodeString/WideString, instead
of simple « string ». Unicode slows down performance, so use it only if you really need Unicode support.
To use Unicode, uncomment {$DEFINE UniCode} in regexpr.pas (remove off).

                                                English                 Deutsch                Français    Español

5.3 FAQ

5.3.1 J’ai trouvé un bug terrible : TRegExpr déclenche une exception de violation
      d’accès !

Réponse
Vous devez créer l’objet avant utilisation. Donc, après avoir déclaré quelque chose comme :

r: TRegExpr

n’oubliez pas de créer l’instance d’objet :

r: = TRegExpr.Create.

5.3.2 Les expressions régulières avec ( ? = . . . ) ne fonctionnent pas

Regarder devant n’est pas implémenté dans le TRegExpr. Mais dans de nombreux cas, vous pouvez facilement le
remplacer par de simples sous-expressions..

5.3.3 Est-ce qu’il prend en charge Unicode ?

Réponse
Comment utiliser Unicode

5.3. FAQ                                                                                                           29
TRegExpr Documentation, Version 1.147

5.3.4 Pourquoi TRegExpr renvoie-t-il plus d’une ligne ?

Par exemple, re ‘‘ ‘‘ renvoie le premier
TRegExpr Documentation, Version 1.147

5.3.8 Je vérifie les entrées de l’utilisateur. Pourquoi TRegExpr renvoie-t-il True
      pour les chaînes d’entrée incorrectes ?

Réponse
Dans de nombreux cas, les utilisateurs de TRegExpr oublient que l’expression régulière est utilisée pour ** rechercher
** dans la chaîne de saisie.
Ainsi, par exemple, si vous utilisez une expression ‘‘ d {4,4} , vous obtiendrez un succès pour les
entrées utilisateur incorrectes telles que ``12345 ou toutes les lettres 1234.
Vous devez vérifier du début à la fin de la ligne pour vous assurer qu’il n’y a plus rien d’autre : ‘‘ ^ d {4,4} $ ‘‘.

5.3.9 Pourquoi les itérateurs non-gourmands fonctionnent-ils parfois comme en
      mode gourmand ?

Par exemple, le r.e. a+?,b+? Appliqué à la chaîne aaa,bbb correspond à aaa,b, mais ne devrait-il pas corres-
pondre à a,b à cause de la non-cupidité du premier itérateur ?
Réponse
C’est à cause de la manière de TRegExpr de travailler. En fait, beaucoup d’autres moteurs fonctionnent exactement
de la même manière : ils ne font que l’optimisation de la recherche simple, et n’essayent pas de faire la meilleure
optimisation.
Dans certains cas, c’est mauvais, mais en commun, c’est plutôt un avantage que une limitation, pour des raisons de
performance et de prévisibilité.
La règle principale - essayez d’abord de faire la correspondance à partir de l’emplacement actuel et seulement si cela
est absolument impossible, avancez d’un caractère et essayez à nouveau de la position suivante dans le texte.
Donc, si vous utilisez «a, b + ?», Cela correspond à «a, b». Dans le cas de a+?,b+?, Ce n’est plus recommandé (nous
ajoutons un modificateur non-glouton) mais il est toujours possible de faire correspondre plus d’un a, donc TRegExpr
le fera.
TRegExpr comme Perl ou Unix ne tente pas d’avancer et de vérifier - ce serait une &quot ;meilleure&quot ; corres-
pondance. En premier lieu, juste parce qu’il n’ya aucun moyen de dire que c’est plus ou moins bon.

5.3.10 Comment utiliser TRegExpr avec Borland C ++ Builder ?

J’ai un problème car aucun fichier d’en-tête (.h ou .hpp) n’est disponible.
Réponse
   — Ajoutez RegExpr.pas au projet bcb.
   — Compiler le projet. Cela génère le fichier d’en-tête RegExpr.hpp.
   — Vous pouvez maintenant écrire du code utilisant l’unité RegExpr.
   — N’oubliez pas d’ajouter «#include« RegExpr.hpp »‘ ‘si nécessaire.
   — N’oubliez pas de remplacer tous les \ dans les expressions régulières par \\ ou redéfinis EscChar const.

5.3.11 Pourquoi beaucoup de solutions (y compris de l’aide et de la démonstration
       TRegExpr) fonctionnent-elles mal dans Borland C ++ Builder ?

Réponse
Le conseil se trouve dans la question précédente ;) Le symbole ‘‘ ‘‘ a une signification particulière dans C++, il
faut donc y échapper (comme décrit dans la réponse précédente). Mais si vous n’aimez pas les choses comme

5.3. FAQ                                                                                                                 31
TRegExpr Documentation, Version 1.147

\\w + \\\\ w + \\. \\ w + ``, vous pouvez redéfinir la constante ``EscChar (dans
RegExpr.pas). Par exemple EscChar = "/". Ensuite, vous pouvez écrire /w+/w+/./w+,
semble inhabituel mais plus lisible.

                                                 Anglais                  Allemand                   Français   Espagnol

5.4 Démos

Code de démonstration pour TRegExpr

5.4.1 introduction

Si vous n’êtes pas familier avec l’expression régulière, jetez un œil à la commande resyntax.
Interface TRegExpr décrite dans la section Interface TRegExpr.

5.4.2 Text2HTML

Sources Text2HTML
Publier du texte brut au format HTML
Utilise l’unité HyperLinksDecorator qui est basé sur TRegExpr.
Cette unité contient des fonctions pour décorer des hyperliens.
Par exemple, remplace «www.masterAndrey.com» par « www.masterAndrey.com » ou «filbert @ yandex.ru» par « fil-
bert@yandex.ru ».

function DecorateURLs (const AText: string; AFlags: TDecorateURLsFlagSet = [durlAddr,
 ˓→durlPath]): string; type TDecorateURLsFlags = (durlProto, durlAddr, durlPort,

 ˓→durlPath, durlBMark, durlParam); TDecorateURLsFlagSet = ensemble de

 ˓→TDecorateURLsFlags; fonction DecorateEMails (const AText: chaîne): chaîne;

                  Valeur        Sens
                  durlProto     Protocole (comme ‘‘ ftp : // ‘‘ ou ‘‘ http : // ‘‘)
                  durlAddr      Adresse TCP ou nom de domaine (comme masterAndrey.com)
                  durlPort      Numéro de port si spécifié (comme : 8080)
                  durlPath      Chemin du document (comme index.html)
                  durlBMark     Marque-page (comme ‘‘ # mark‘‘)
                  durlParam     Paramètres d’URL (comme ? ID = 2 & User = 13)

Retourne le texte saisi AText avec des hyperliens décorés.
AFlags décrit quelles parties de l’hyperlien doivent être incluses dans la partie visible du lien.
Par exemple, si AFlags est‘ [durlAddr], alors l’hyperlien www.masterAndrey.com/contacts.htm sera décoré
comme ‘‘ www.masterAndrey.com ‘‘.

32                                                                                     Chapitre 5. Documentation
TRegExpr Documentation, Version 1.147

5.4.3 TRegExprRoutines

Exemples très simples, voir les commentaires à l’intérieur de l’unité

5.4.4 TRegExprClass

Exemples légèrement plus complexes, voir les commentaires à l’intérieur de l’unité

5.4. Démos                                                                                                33
TRegExpr Documentation, Version 1.147

34                                      Chapitre 5. Documentation
CHAPITRE            6

                                                                                                     Traductions

La documentation est disponible en anglais et en russe ‘_.
Il existe également d’anciennes traductions en allemand, bulgare, français et espagnol. Si vous voulez aider à mettre à
jour ces anciennes traductions, veuillez me contacter. ‘_.
New translations are based on GetText and can be edited with Weblate.
Ils sont déjà traduits automatiquement et ne nécessitent que la correction d’épreuves. Il peut s’agir d’un copier-coller
d’anciennes traductions.

                                                                                                                     35
TRegExpr Documentation, Version 1.147

36                                      Chapitre 6. Traductions
CHAPITRE          7

                                                                                        Reconnaissance

Beaucoup de fonctionnalités suggérées et beaucoup de bugs fondés (et même corrigés) par les contributeurs de TRe-
gExpr.
Je ne peux pas tous les énumérer ici, mais j’apprécie tous les rapports de bugs, suggestions de fonctionnalités et
questions que je reçois de votre part.
    — Alexey Torgashin - added many features in 2019-2020, e.g. named groups, non-capturing groups, assertions,
       backward search
    — Guido Muehlwitz - bogue trouvé et corrigé dans le traitement d’une grosse chaîne
    — Stephan Klimek - testing in C++Builder and suggesting/implementing many features
    — Steve Mudford - Paramètre de décalage implémenté
    — Martin Baur (www.mindpower.com) - traduction allemande, suggestions utiles
    — Yury Finkel - implemented Unicode support, found and fixed some bugs
    — Ralf Junker - implemented some features, many optimization suggestions
    — Simeon Lilov - traduction en bulgare
    — Filip Jirsk and Matthew Winter - help in implementation non-greedy mode
    — Kit Eason - many examples for introduction help section
    — Juergen Schroth - chasse aux insectes et suggestions utiles
    — Martin Ledoux - traduction française
    — Diego Calp, Argentine - traduction espagnole

                                                                                                               37
Vous pouvez aussi lire