PHPEdit vous permet de rechercher et remplacer du texte dans l'éditeur en utilisant les options de menu Edit, Find... et Edit, Replace... Chaque dialogue dispose d'une case à cocher 'Expressions Régulières' qui permet de choisir si la recherche est faite sous forme d'expressions régulières ou de texte normal. L'option texte normal permet une recherche et un remplacement de texte exact et devrait être familière à la plupart des utilisateurs. Les expressions régulières peuvent être utilises pour effectuer des opérations de recherche plus complexes. Par exemple, pour trouver toutes les variables dans un script PHP, il est déterminé que toutes les variables ne peuvent commencer que par certains caractères et n'être composées que de certains autres caractères. Les expressions régulières permettent de décrire ce genre de spécifications en utilisant une syntaxe inspirée d'outils tels que GREP, LEX et YACC.
Les définitions de syntaxe suivantes utilisent les expressions régulières EBNF.
Une expression regulière est composée d'une séquence de sous-expressions, chacune sous la forme d'opérateurs décrits dans la table ci-dessous. L'expression elle-même peut etre précédée de ^ pour indiquer que l'expression ne peut être recherchée qu'au début d'une ligne, ou terminér par un $ pour indiquer que l'expression ne peut être recherchée qu'à la fin d'une ligne.
TSyntaxMemo retourne des détails sur les différentes composantes d'une expression régulière. Ces composantes sont définies dans leur syntaxe formelle par le construct <term>. Par exemple, l'expression '[a-zA-Z][a-zA-Z0-9_]*' reconnaît un texte qui commence par une lettre ([a-zA-Z]) et qui est éventuellement suivi par des caractères alphanumériques ([a-zA-Z0-9_]*). La section zéro est donc le caractère satisfaisant [a-zA-Z] et la section un correspond aux caractères satisfaisant [a-zA-Z0-9_]*. So l'expression est comprise entre des parenthèses: ([a-zA-Z][a-zA-Z0-9_]*) cette partie est considérée comme un unique <term> et donc comme une seule composante.
EBNF (Extended Backaus-Naur Form - Forme Etendue de Backaus-Naur) est un style de spécification utilisér pour la description formelle d'une syntaxe. Dans la description de la syntaxe, les metacaractères suivants sont utilisés:
a ::= b L'élément a est défini par l'élément b [a] Indique que l'élément a est optionnel (abc) Indique que les éléments a, b et c sont considérés comme un seul élément a|b Indique que l'on considère soit l'élément a, soit l'élément b 'abc' Les caractères 'a', suivi de 'b' suivi de 'c' <a> Single syntax construct a defined in the specification
("http://"|"mailto:"|"ftp://")[^ \n\r\"\<\\]+
Permettrait la détection d'adresses internet commençant par 'http://', 'mailto://' ou 'ftp://'. The <field values> will be assigned based upon the syntax element <factor> and devolve to:
%1.....("http://"|"mailto:"|"ftp://")
%2.....[^ \n\r\"\<\\]+
En français, cette expression pourrait s'exprimer ainsi: "Trouver toutes les occurences de texte commençant par 'http://', 'mailto://' ou 'ftp://' et suivies par au moins un caractère qui n'est pas un des suivants: espace (\s), nouvelle ligne (\n), retour chariot (\r), guillement (\"), signe inférieur (\<), ou un slash (\\)"
"{$"[a-zA-Z_]+[\s\t\r\n]*[^\}]*"}"
Créerait les valeurs comme suit:
%1....."{$"
%2.....[a-zA-Z_]+
%3.....[\s\t\r\n]*
%4.....[^\}]*
%5....."}"
En français, cette expression pourrait s'exprimer ainsi: "Trouver toutes les occurences de texte commençant par une accolate et un signe dollar ("{$") et suivies dau moins une letre ou blanc souligné ([a-zA-Z_]+) et éventuellement suivies par des blancs ([\s\t\r\n]*) éventuellement suivis d'un nombre quelconque de n'importe quels caractères à part une accolate fermante ([^\}]*) et terminé par une accolade fermante ("}")
La description formelle de la syntaxe supportée par TSyntaxMemo est la suivante:
<regular expression> ::= [ '^' ] <expression> [ '$' ]
<expression> ::= <term> [ '|' <expression> ]
<term> ::= <factor> [ [ '||' ] <term> ]
<factor> ::= <char atom> [ <modifier> ]
<char atom> ::= <char> |
<string> |
<charclass> |
'.' |
( '(' <expression> ')' )
<string> ::= '"' <charlist> '"'
<charlist> ::= <char> [ <charlist> ]
<charclass> ::= '[' [ '^' ] <CClist> ']'
<CClist> ::= <one CChar> [ <CClist> ]
<one CChar> ::= <char> [ '-' <char> ]
<modifier> ::= '*' |
'+' |
'?' |
<interval specifier>
<interval specifier> ::= '{' [ <low> ',' ] | [ ',' <high> ] | [ <low> ',' <high> ] '}'
<low> ::= <Value>
<high> ::= <Value>
<Value> ::= <Decimal value>
<Decimal value> ::= <Decimal digit> [ <Decimal value> ]
<char> ::= <escaped char> |
<plain char>
<escaped char> ::= '\' <escape sequence>
<escape sequence> ::= 'x' <Hex value> |
'0' <Octal value> |
'n' |
't' |
'r' |
'b' |
'f' |
<plain char>
<Hex value> ::= <Hex digit> [ <Hex digit> ]
<Hex digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |
'a' | 'b' | 'c' | 'd' | 'e' | 'f' |
'A' | 'B' | 'C' | 'D' | 'E' | 'F'
<Decimal digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
<Octal value> ::= <Octal digit> [ <Octal digit> ] [ <Octal digit> ]
<Octal digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'
<plain char> ::= N'importe quel caractère visible (voir note 1)
<plain char> les caractères spéciaux comme '*', '?', etc. doivent être échappés pour éviter l'interprétation non désirées.
<octal value> doit résulter en une valeur sur 8 bits. Un maximum de 3 <octal digit> sera utilisé pour déterminer la <octal value>. Tout autre caractère sera considéré comme <char atom>s après la <octal value>. Si la <octal value> donne une valeur > 255 (i.e. \0377) une erreur sera retournée.
<hex value> acceptera au maximum 2 chiffres hexa; tout autre sera considéré comme <char atom>s. Pour évier l'ambiguité, n'utiliser que des codes hexà à deux caractères, comme \x0F etc.
Les <modifier>s sont interprétés comme suit:
'*' Zéro ou plus de
'+' Un ou plus de
'?' Zero ou un de (i.e. optionel)
A accent circonflexe (^) au début d'une expression régulière correspond au début de ligne. Un dollar ($) à la fin de l'expression correspond à la fin de la ligne. Aucun des deux ne comprend les caractères de début/fin de ligne dans le texte reconnu.
Les lettres de type <escaped char> letters peuvent être en majuscules ou minuscules et sont interprétées comme suit:
\r Retour chariot (code ASCII 10) \n Nouvelle ligne (code ASCII 13) \f Form feed (code ASCII 12) \t Tabulation (code ASCII 9) \b Retour arrière (code ASCII 8)
a+ Une ou plus occurences de a
a* Zéro ou plus occurences de a
a? Zéro ou une (i.e. optionel) occurences de a
a{n} Exactement n occurences de a
a{n,} n ou plus occurences de a
a{,m} de zéro à m occurences de a
a{n,m} de n à m occurences de a
a|b a ou b
a||b a ou b ou encore a et b dans n'importe quel ordre
abc a suivi de b suivi de c
[abc] Un seul caractère parmi a, b et c
[a-b] Un seul caractère allant de a à b, a et b compris
[^abc] Un seul caractère qui n'est pas a, b ou c
(abc) a suivi de a suivi de b suivi de c
"abc" A suivi de b suivi de c sans aucun signification particulière attachée à a, b ou c
. N'importe quel caractère sauf une nouvelle ligne
\a La lettre a, sans aucune signification particulière attachée à a. Caractères spéciaux:
\t Tabulation
\n Nouvelle ligne
\r Retour
\f Formfeed
\b Retour arrière
\xNN Le caractère hexadécimal NN
\0ooo Le caractère octal ooo
\w Un seul caractère ([a-zA-Z0-9_])
\W Tout caractère n'étant pas de la classe ([^a-zA-Z0-9_])
\d Un chiffre ([0-9])
\D N'importe quoi sauf un chiffre ([^0-9])
\s Un caractère d'espacement [\t\r\n\f\b\ ]
\S N'importe quoi sauf un caractère d'espacement
| Expression | Correspond à... | Ne correspond à... |
| "ceci"|"cela" | ceci | Cela |
| "ceci"|"cela" | ceci | cela |
| \d{2}\.\d{2} | 23.45 | 2.4 |
| \d{2}\.\d{2} | 3.22 | 0.1 |
| [a-zA-Z_]\w* | Identifiant | 2Identifiants |
| \(\*[\x01-\x7F]+\*\) | /* a comment */ | /* No comment */ |
Un texte de remplacement est défini par
<replacement text> ::= <char specifier list>
<char specifier list> ::= <char specifier> [ <char specifier list> ]
<char specifier> ::= <field value> |
<escaped char> |
<plain char>
<field value> ::= '%' <decimal value>
<decimal value> ::= <decimal digit> [ <decimal value> ]
<decimal digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
<escaped char> et <plain char> sont identiques à la syntaxe des expressions régulières.
La <decimal value> doit correspondre à un nombre de 0 à 10.