perlreapi - En ligne dans le Cloud

PROGRAMME:

Nom

perlreapi - Interface du plug-in d'expressions régulières Perl

DESCRIPTION

Depuis Perl 5.9.5, il existe une nouvelle interface pour le branchement et l'utilisation d'expressions régulières
moteurs autres que celui par défaut.

Chaque moteur est censé donner accès à une structure constante du format suivant :

typedef struct regexp_engine {
REGEXP* (*comp) (pTHX_
const SV * modèle const, drapeaux const U32);
I32 (*exécutable) (pTHX_
REGEXP * const rx,
car* stringarg,
char* strend, char* strbeg,
STaille_t minend, SV* sv,
données void*, drapeaux U32);
char* (*intuition) (pTHX_
REGEXP * const rx, SV * sv,
const char * const strbeg,
char *strpos, char *strend, drapeaux U32,
struct re_scream_pos_data_s *données);
SV* (*checkstr) (pTHX_REGEXP * const rx);
void (*libre) (pTHX_REGEXP * const rx);
vide (*numbered_buff_FETCH) (pTHX_
REGEXP * const rx,
const I32 parent,
SV * const sv);
vide (*numbered_buff_STORE) (pTHX_
REGEXP * const rx,
const I32 parent,
SV const * valeur const);
I32 (*numbered_buff_LENGTH) (pTHX_
REGEXP * const rx,
const SV * const sv,
const I32 parent);
SV* (*named_buff) (pTHX_
REGEXP * const rx,
SV * clé const,
SV * valeur const,
drapeaux U32);
SV* (*named_buff_iter) (pTHX_
REGEXP * const rx,
const SV * const dernière clé,
drapeaux const U32);
SV* (*qr_package)(pTHX_REGEXP * const rx);
#ifdef USE_ITHREADS
void* (*dupe) (pTHX_REGEXP * const rx, CLONE_PARAMS *param);
#endif
REGEXP* (*op_comp) (...) ;

Lorsqu'une expression rationnelle est compilée, son champ « engine » est alors défini pour pointer vers l'expression appropriée
structure, de sorte que lorsqu'elle doit être utilisée, Perl peut trouver les bonnes routines pour le faire.

Afin d'installer un nouveau gestionnaire d'expressions rationnelles, $^H{regcomp} est défini sur un entier qui (lorsque
casté de manière appropriée) se résout à l'une de ces structures. Lors de la compilation, le "comp"
est exécutée, et le champ moteur de la structure "regexp" résultante devrait
renvoient à la même structure.

Le symbole pTHX_ dans la définition est une macro utilisée par Perl sous le threading pour fournir un
argument supplémentaire à la routine retenant un pointeur vers l'interpréteur en cours d'exécution
l'expression régulière. Ainsi, sous threading, toutes les routines obtiennent un argument supplémentaire.

Rappels

comp
REGEXP* comp(pTHX_ const SV * modèle const, drapeaux const U32);

Compilez le motif stocké dans "pattern" en utilisant les "drapeaux" donnés et renvoyez un pointeur vers un
structure "REGEXP" préparée qui peut effectuer le match. Voir "La structure REGEXP" ci-dessous
pour une explication des champs individuels dans la structure REGEXP.

Le paramètre "pattern" est le scalaire qui a été utilisé comme modèle. Les versions précédentes de
Perl passerait deux "char*" indiquant le début et la fin du motif stringifié ; la
L'extrait suivant peut être utilisé pour obtenir les anciens paramètres :

STRLEN plen ;
char* exp = SvPV(motif, plen);
char* xend = exp + plen ;

Comme n'importe quel scalaire peut être passé en tant que modèle, il est possible d'implémenter un moteur qui
fait quelque chose avec un tableau (""ook" =~ [ qw/ eek hlagh / ]") ou avec le non-stringified
forme d'une expression régulière compilée (""ook" =~ qr/eek/"). Le propre moteur de Perl sera toujours
stringifiez tout à l'aide de l'extrait ci-dessus, mais cela ne signifie pas que les autres moteurs doivent le faire.

Le paramètre "flags" est un champ de bits qui indique lequel des "msixpn" marque le regex
a été compilé avec. Il contient également des informations supplémentaires, telles que si "utiliser les paramètres régionaux" est dans
effet.

Les drapeaux "eogc" sont supprimés avant d'être transmis à la routine comp. L'expression régulière
le moteur n'a pas besoin de savoir si l'un d'entre eux est défini, car ces indicateurs ne devraient affecter que
ce que Perl fait avec le modèle et ses variables de correspondance, pas comment il est compilé et
réalisé.

Au moment où le rappel de composition est appelé, certains de ces indicateurs ont déjà pris effet
(noté ci-dessous le cas échéant). Cependant la plupart de leur effet se produit après la comp
callback a été exécuté, dans des routines qui lisent le champ "rx->extflags" qu'il remplit.

En général, les drapeaux doivent être conservés dans "rx->extflags" après la compilation, bien que le
le moteur regex peut vouloir ajouter ou supprimer certains d'entre eux pour invoquer ou désactiver certains
comportement en Perl. Les drapeaux ainsi que tout comportement spécial qu'ils provoquent sont documentés
ci-dessous :

Les modificateurs de motifs :

"/m" - RXf_PMf_MULTILINE
Si c'est dans "rx->extflags", il sera passé à "Perl_fbm_instr" par "pp_split" qui
traitera la chaîne d'objet comme une chaîne multiligne.

"/s" - RXf_PMf_SINGLELINE
"/i" - RXf_PMf_FOLD
"/x" - RXf_PMf_EXTENDED
S'il est présent sur une expression régulière, les commentaires "#" seront traités différemment par le tokenizer dans
certains cas.

À FAIRE : Documentez ces cas.

"/p" - RXf_PMf_KEEPCOPY
À FAIRE : Documentez-le

Jeu de caractères
Les règles de jeu de caractères sont déterminées par une énumération contenue dans ce champ.
Ceci est encore expérimental et sujet à changement, mais l'interface actuelle renvoie
les règles à l'aide de la fonction en ligne "get_regex_charset(const U32 flags)". le
seule la valeur actuellement documentée qui en est renvoyée est REGEX_LOCALE_CHARSET, qui est définie
si "use locale" est en vigueur. S'il est présent dans "rx->extflags", "split" utilisera le
définition des espaces blancs dépendante des paramètres régionaux lorsque RXf_SKIPWHITE ou RXf_WHITE est dans
effet. Les espaces blancs ASCII sont définis selon isSPACE et par les macros internes
"is_utf8_space" sous UTF-8 et "isSPACE_LC" sous "use locale".

Drapeaux supplémentaires :

RXf_SPLIT
Ce drapeau a été supprimé dans perl 5.18.0. "split ' '" est maintenant un cas spécial uniquement dans le
analyseur. RXf_SPLIT est toujours #défini, vous pouvez donc le tester. C'est comme ça qu'avant
travail:

Si "split" est invoqué comme "split ' '" ou sans arguments (ce qui signifie vraiment "split('
', $_)", voir split), Perl définira ce drapeau. Le moteur de regex peut alors le vérifier
et définissez les indicateurs SKIPWHITE et WHITE. Pour ce faire, le moteur Perl fait :

if (flags & RXf_SPLIT && r->prelen == 1 && r->precomp[0] == ' ')
r->extflags |= (RXf_SKIPWHITE|RXf_WHITE);

Ces drapeaux peuvent être définis lors de la compilation pour permettre des optimisations dans l'opérateur "split".

RXf_SKIPWHITE
Ce drapeau a été supprimé dans perl 5.18.0. Il est toujours #défini, vous pouvez donc le définir, mais
cela n'aura aucun effet. Voici comment cela fonctionnait :

Si le drapeau est présent dans "rx->extflags", "split" supprimera les espaces blancs depuis le début
de la chaîne d'objet avant qu'elle ne soit opérée. Ce qui est considéré comme un espace dépend
activé si le sujet est une chaîne UTF-8 et si le drapeau "RXf_PMf_LOCALE" est défini.

Si RXf_WHITE est défini en plus de ce drapeau, "split" se comportera comme "split " ""
sous le moteur Perl.

RXf_START_ONLY
Indique à l'opérateur de fractionnement de fractionner la chaîne cible sur des sauts de ligne ("\n") sans
en invoquant le moteur regex.

Le moteur de Perl définit cela si le motif est "/^/" ("plen == 1 && *exp == '^'"), même
sous "/^/s" ; voir scission. Bien sûr, un moteur de regex différent pourrait vouloir utiliser le
mêmes optimisations avec une syntaxe différente.

RXf_BLANC
Indique à l'opérateur de fractionnement de fractionner la chaîne cible sur des espaces sans invoquer le
moteur d'expression régulière. La définition des espaces blancs varie selon que la chaîne cible
est une chaîne UTF-8 et activé si RXf_PMf_LOCALE est défini.

Le moteur de Perl définit ce drapeau si le motif est "\s+".

RXf_NULL
Indique à l'opérateur de fractionnement de fractionner la chaîne cible en caractères. La définition de
Le caractère varie selon que la chaîne cible est une chaîne UTF-8.

Le moteur de Perl définit ce drapeau sur des motifs vides, cette optimisation fait "split //"
beaucoup plus vite qu'il ne le serait autrement. C'est encore plus rapide que "déballer".

RXf_NO_INPLACE_SUBST
Ajouté dans perl 5.18.0, ce drapeau indique qu'une expression régulière peut effectuer un
opération qui interférerait avec la substitution en place. Par exemple, il pourrait
contenir lookbehind, ou affecter à des variables non magiques (telles que $REGMARK et
$REGERROR) pendant la correspondance. « s/// » ignorera certaines optimisations lorsque cela est défini.

exec
I32 exec(pTHX_REGEXP * const rx,
char *stringarg, char* strend, char* strbeg,
STaille_t minend, SV* sv,
données void*, drapeaux U32);

Exécutez une expression rationnelle. Les arguments sont

rx L'expression régulière à exécuter.

sv C'est le SV à comparer. Notez que le tableau de caractères réel à apparier
contre est fourni par les arguments décrits ci-dessous; le SV est juste utilisé pour déterminer
UTF8ness, "pos()" etc.

strbeg
Pointeur vers le début physique de la chaîne.

tendance
Pointeur vers le caractère suivant la fin physique de la chaîne (c'est-à-dire le "\0", si
tout).

cordes
Pointeur vers la position dans la chaîne où la correspondance doit commencer ; ce n'est peut-être pas
égal à "strbeg" (par exemple dans une itération ultérieure de "/.../g").

mentir
Longueur minimale de la chaîne (mesurée en octets à partir de "stringarg") qui doit correspondre ; si la
le moteur atteint la fin du match mais n'a pas atteint cette position dans la chaîne, il
devrait échouer.

données
Données d'optimisation ; sous réserve de modifications.

drapeaux
Indicateurs d'optimisation ; sous réserve de modifications.

Intuit
car* intuit(pTHX_
REGEXP * const rx,
SV *sv,
const char * const strbeg,
caractère *strpos,
char *tendance,
drapeaux const U32,
struct re_scream_pos_data_s *données);

Trouvez la position de départ où une correspondance regex doit être tentée, ou éventuellement si la regex
le moteur ne doit pas être exécuté car le modèle ne peut pas correspondre. C'est ce qu'on appelle, selon le cas,
par le noyau, en fonction des valeurs du membre "extflags" de la structure "regexp".

Arguments:

rx : la regex à comparer
sv : le SV correspondant : utilisé uniquement pour le drapeau utf8 ; la chaîne
lui-même est accessible via les pointeurs ci-dessous. Notez que sur
quelque chose comme un SV surchargé, SvPOK(sv) peut être faux
et les pointeurs de chaîne peuvent pointer vers quelque chose sans rapport avec
le SV lui-même.
strbeg : vrai début de chaîne
strpos : le point de la chaîne auquel commencer la correspondance
strend : pointeur sur l'octet suivant le dernier caractère de la chaîne
indicateurs actuellement inutilisés ; mis à 0
données : actuellement inutilisées ; mis à NULL

chaîne de contrôle
SV* checkstr(pTHX_REGEXP * const rx);

Renvoie un SV contenant une chaîne qui doit apparaître dans le motif. Utilisé par "split" pour
optimisation des matchs.

gratuitement
void free(pTHX_REGEXP * const rx);

Appelé par Perl lorsqu'il libère un modèle d'expression régulière afin que le moteur puisse libérer n'importe quel
ressources pointées par le membre "pprivate" de la structure "regexp". C'est seulement
responsable de la libération des données privées ; Perl gérera la libération de tout autre contenu
dans la structure "regexp".

numérotée capturer rappels
Appelé pour obtenir/définir la valeur de "$`", "$'", $& et leurs équivalents nommés, ${^PREMATCH},
${^POSTMATCH} et ${^MATCH}, ainsi que les groupes de capture numérotés ($1, $2, ...).

Le paramètre "paren" sera 1 pour $1, 2 pour $2 et ainsi de suite, et aura ces symboles
valeurs pour les variables spéciales :

${^PREMATCH} RX_BUFF_IDX_CARET_PREMATCH
${^POSTMATCH} RX_BUFF_IDX_CARET_POSTMATCH
${^MATCH} RX_BUFF_IDX_CARET_FULLMATCH
$` RX_BUFF_IDX_PREMATCH
$' RX_BUFF_IDX_POSTMATCH
$& RX_BUFF_IDX_FULLMATCH

Notez que dans Perl 5.17.3 et les versions antérieures, les trois dernières constantes ont également été utilisées pour le
caret variantes des variables.

Les noms ont été choisis par analogie avec les noms de méthodes Tie::Scalar avec un
LONGUEUR rappel pour plus d'efficacité. Cependant, les variables de capture nommées ne sont actuellement pas liées
en interne mais mis en œuvre via la magie.

numéroté_buff_FETCH

void numbered_buff_FETCH(pTHX_REGEXP * const rx, const I32 paren,
SV * const sv);

Récupérer une capture numérotée spécifiée. "sv" doit être défini sur le scalaire à renvoyer, le
scalaire est passé en argument plutôt que d'être renvoyé par la fonction car lorsque
ça s'appelle Perl a déjà un scalaire pour stocker la valeur, en créer un autre serait
redondant. Le scalaire peut être défini avec "sv_setsv", "sv_setpvn" et ses amis, voir perlapi.

Ce rappel est l'endroit où Perl efface ses propres variables de capture en mode taint (voir
perlsec). Voir la fonction "Perl_reg_numbered_buff_fetch" dans regcomp.c pour savoir comment nettoyer
capturez des variables si c'est quelque chose que vous aimeriez que votre moteur fasse également.

numéroté_buff_STORE

vide (*numbered_buff_STORE) (pTHX_
REGEXP * const rx,
const I32 parent,
SV const * valeur const);

Définissez la valeur d'une variable de capture numérotée. "valeur" est le scalaire qui doit être utilisé comme
la nouvelle valeur. C'est au moteur de s'assurer qu'elle est utilisée comme nouvelle valeur (ou
le rejeter).

Mise en situation :

if ("ook" =~ /(o*)/) {
# 'paren' sera '1' et 'value' sera 'ee'
$1 =~ tr/o/e/;
}

Le propre moteur de Perl croasse à toute tentative de modification des variables de capture, pour le faire dans
un autre moteur utilise le rappel suivant (copié de "Perl_reg_numbered_buff_store") :

annuler
Exemple_reg_numbered_buff_store(pTHX_
REGEXP * const rx,
const I32 parent,
SV const * valeur const)
{
PERL_UNUSED_ARG(rx);
PERL_UNUSED_ARG(parent);
PERL_UNUSED_ARG(valeur);

si (!PL_localizing)
Perl_croak(aTHX_PL_no_modify);
}

En fait, Perl ne toujours croasser dans une déclaration qui semble modifier une
variable de capture numérotée. C'est parce que le rappel STORE ne sera pas appelé si Perl
peut déterminer qu'il n'a pas à modifier la valeur. C'est exactement comment lié
les variables se comportent dans la même situation :

paquet CaptureVar;
utiliser le parent 'Cravate::Scalaire' ;

sous TIESCALAR { bénir [] }
sous FETCH { undef }
sub STORE { die "Ceci ne s'appelle pas" }

paquet principal;

tie my $sv => "CaptureVar" ;
$sv =~ y/a/b/;

Étant donné que $sv est "undef" lorsque l'opérateur "y///" lui est appliqué, la translittération
ne s'exécutera pas réellement et le programme ne "mourra pas". Ceci est différent de la façon dont 5.8 et
les versions antérieures se comportaient puisque les variables de capture étaient alors des variables READONLY ; à présent
ils mourront simplement lorsqu'ils seront affectés dans le moteur par défaut.

numéroté_buff_LENGTH

I32 numéroté_buff_LENGTH (pTHX_
REGEXP * const rx,
const SV * const sv,
const I32 parent);

Obtenez la "longueur" d'une variable de capture. Il y a un rappel spécial pour cela afin que Perl
n'a pas besoin de faire un FETCH et d'exécuter "length" sur le résultat, puisque la longueur est (dans Perl
case) connu à partir d'un offset stocké dans "rx->offs", c'est beaucoup plus efficace :

I32 s1 = rx->offs[paren].start ;
I32 s2 = rx->offs[paren].end;
I32 longueur = t1 - s1 ;

C'est un peu plus complexe dans le cas de l'UTF-8, voyez ce que
"Perl_reg_numbered_buff_length" fait avec is_utf8_string_loclen.

Nommé capturer rappels
Appelé pour obtenir/définir la valeur de "%+" et "%-", ainsi que par certaines fonctions utilitaires dans re.

Il y a deux rappels, "named_buff" est appelé dans tous les cas FETCH, STORE, DELETE,
CLEAR, EXISTS et SCALAR Tie::Les rappels de hachage seraient sur les modifications apportées à "%+" et "%-" et
"named_buff_iter" dans les mêmes cas que FIRSTKEY et NEXTKEY.

Le paramètre "flags" peut être utilisé pour déterminer laquelle de ces opérations les rappels
devrait répondre. Les drapeaux suivants sont actuellement définis :

Quelle opération Tie::Hash est effectuée à partir du niveau Perl sur "%+" ou "%+", le cas échéant :

RXapif_FETCH
RXapif_STORE
RXapif_DELETE
RXapif_CLEAR
RXapif_EXISTE
RXapif_SCALAIRE
RXapif_FIRSTKEY
RXapif_NEXTKEY

Si « %+ » ou « %- » est utilisé, le cas échéant.

RXapif_ONE /* %+ */
RXapif_ALL /* %- */

Si cela s'appelle "re::regname", "re::regnames" ou "re::regnames_count", le cas échéant.
Les deux premiers seront combinés avec "RXapif_ONE" ou "RXapif_ALL".

RXapif_REGNAME
RXapif_REGNAMES
RXapif_REGNAMES_COUNT

En interne, "%+" et "%-" sont implémentés avec une véritable interface liée via
Tie::Hash::NamedCapture. Les méthodes de ce package rappelleront ces fonctions.
Cependant, l'utilisation de Tie::Hash::NamedCapture à cette fin pourrait changer à l'avenir
libère. Par exemple, cela pourrait être implémenté par magie à la place (il faudrait un
extension à mgvtbl).

nommé_buff

SV* (*named_buff) (pTHX_REGEXP * const rx, SV * const key,
SV * valeur const, drapeaux U32);

nommé_buff_iter

SV* (*named_buff_iter) (pTHX_
REGEXP * const rx,
const SV * const dernière clé,
drapeaux const U32);

qr_paquet
SV* qr_package(pTHX_REGEXP * const rx);

Le paquet dans lequel l'objet magique qr// est béni (comme vu par "ref qr//"). Il est
recommandé que les moteurs remplacent ce nom par leur nom de package pour l'identification indépendamment de
ou s'ils implémentent des méthodes sur l'objet.

Le package renvoyé par cette méthode doit également avoir le package interne "Regexp" dans son
@EST UN. "qr//->isa("Regexp")" devrait toujours être vrai quel que soit le moteur utilisé
utilisé.

Un exemple de mise en œuvre pourrait être :

VS*
Example_qr_package(pTHX_REGEXP * const rx)
{
PERL_UNUSED_ARG(rx);
return newSVpvs("re::engine::Example");
}

Tout appel de méthode sur un objet créé avec "qr//" sera envoyé au package en tant que
objet normal.

utiliser re::engine::Exemple ;
mon $re = qr//;
$re->meth ; # envoyé à re::engine::Example::meth()

Pour récupérer l'objet "REGEXP" du scalaire dans une fonction XS utilisez la macro "SvRX",
voir "Fonctions REGEXP" dans perlapi.

void meth (SV * rv)
CODE PP :
REGEXP * re = SvRX(sv);

dupe
void* dupe(pTHX_REGEXP * const rx, CLONE_PARAMS *param);

Sur les constructions threadées, une regexp peut avoir besoin d'être dupliquée afin que le modèle puisse être utilisé par
plusieurs fils. Cette routine est censée gérer la duplication de toutes les données privées
pointé par le membre "pprivate" de la structure "regexp". Il sera appelé avec le
nouvelle structure "regexp" préconstruite comme argument, le membre "pprivate" pointera vers
le et les sites anciens structure privée, et c'est la responsabilité de cette routine de construire une copie et
renvoie un pointeur vers celui-ci (que Perl utilisera ensuite pour écraser le champ tel qu'il est passé à ce
routine.)

Cela permet au moteur de duper ses données privées mais aussi si besoin de modifier le rendu final
structure s'il le faut vraiment.

Sur les builds non threadés, ce champ n'existe pas.

op_comp
Ceci est privé du noyau Perl et sujet à changement. Devrait être laissé nul.

Le REGEXP structure

La structure REGEXP est définie dans expression rationnelle.h. Tous les moteurs de regex doivent pouvoir correctement
construire une telle structure dans leur routine "comp".

La structure REGEXP contient toutes les données dont Perl a besoin pour fonctionner correctement
avec l'expression régulière. Il comprend des données sur les optimisations que Perl peut utiliser pour
déterminer si le moteur regex doit vraiment être utilisé, et diverses autres informations de contrôle qui
est nécessaire pour exécuter correctement les modèles dans divers contextes, par exemple si le modèle
ancré d'une manière ou d'une autre, ou quels indicateurs ont été utilisés lors de la compilation, ou si le programme
contient des constructions spéciales dont Perl doit être conscient.

De plus, il contient deux champs qui sont destinés à l'usage privé de la regex
moteur qui a compilé le modèle. Ce sont les membres "intflags" et "pprivate".
"pprivate" est un pointeur vide vers une structure arbitraire, dont l'utilisation et la gestion est le
responsabilité du moteur de compilation. Perl ne modifiera jamais aucune de ces valeurs.

expression rationnelle de structure typedef {
/* quel moteur a créé cette expression rationnelle ? */
moteur const struct regexp_engine* ;

/* de quoi s'agit-il d'une copie légère ? */
struct regexp* mère_re;

/* Informations sur la correspondance que le noyau Perl utilise pour gérer
* des choses */
U32 extflags ; /* Indicateurs utilisés à la fois en externe et en interne */
I32 minlen; /* nombre minimum possible de caractères dans */
chaîne à rechercher */
I32 minlenret ; /* nombre de caractères minimum possible dans $& */
U32 gofs; /* caractères à gauche de pos que nous recherchons */

/* données de sous-chaîne sur les chaînes qui doivent apparaître
dans le match final, utilisé pour les optimisations */
struct reg_substr_data *substrs ;

U32 nparens; /* nombre de groupes de capture */

/* données privées spécifiques au moteur */
drapeaux internationaux U32 ; /* Indicateurs internes spécifiques au moteur */
void *pprivé; /* Données privées au moteur de regex qui
créé cet objet. */

/* Données sur la dernière/actuelle correspondance. Ceux-ci sont modifiés au cours
* correspondant à*/
U32 dernier parent ; /* parent proche le plus élevé correspondant ($+) */
U32 lastcloseparent; /* dernier parent proche correspondant ($^N) */
regexp_paren_pair *swap; /* Copie d'échange de *offs */
regexp_paren_pair *offs; /* Tableau de décalages pour (@-) et
(@+) */

char *subbeg; /* chaîne enregistrée ou d'origine donc \digit fonctionne
toujours. */
SV_SAVED_COPY /* Si non NULL, SV qui est COW de l'original */
I32 sublen; /* Longueur de la chaîne pointée par subbeg */
sous-décalage I32 ; /* décalage d'octet de subbeg à partir du début logique de
chaîne */
sous-coffre I32 ; /* suboffset equiv, mais en caractères (pour @-/@+) */

/* Informations sur la correspondance qui ne sont pas souvent utilisées */
I32 prélen; /* longueur de la précomp */
const char *precomp; /* expression régulière de pré-compilation */

char *enveloppé ; /* version encapsulée du motif */
enveloppe I32 ; /* longueur de l'enrubanné */

I32 vu_evals; /* nombre de groupes eval dans le modèle - pour
contrôles de sécurité */
HV *noms_parents ; /* Hachage facultatif des noms de parent */

/* Refcount de cette expression régulière */
I32 réfcnt; /* Refcount de cette expression régulière */
} expression rationnelle ;

Les champs sont discutés plus en détail ci-dessous :

"moteur"
Ce champ pointe vers une structure "regexp_engine" qui contient des pointeurs vers le
sous-programmes qui doivent être utilisés pour effectuer une correspondance. C'est la routine de compilation
responsabilité de remplir ce champ avant de renvoyer l'objet regexp.

En interne, il est défini sur "NULL" à moins qu'un moteur personnalisé ne soit spécifié dans $^H{regcomp},
Le propre ensemble de rappels de Perl est accessible dans la structure pointée par "RE_ENGINE_PTR".

"mère_re"
A FAIRE, voirhttp://www.mail-archive.com/perl5-changes@perl.org/msg17328.html>

« drapeaux extérieurs »
Cela sera utilisé par Perl pour voir avec quels drapeaux l'expression rationnelle a été compilée, cela
normalement être défini sur la valeur du paramètre flags par le rappel comp. Voir la maquette
documentation pour les drapeaux valides.

"minlen" "minlenret"
La longueur de chaîne minimale (en caractères) requise pour que le modèle corresponde. Ceci est utilisé
pour élaguer l'espace de recherche en ne prenant pas la peine de faire correspondre plus près de la fin d'une chaîne que
permettrait un match. Par exemple, il ne sert à rien de démarrer le moteur de regex si
le minlen est de 10 mais la chaîne ne fait que 5 caractères. Il n'y a aucun moyen que le
le motif peut correspondre.

"minlenret" est la longueur minimale (en caractères) de la chaîne qui serait trouvée dans $&
après un match.

La différence entre "minlen" et "minlenret" peut être vue dans le schéma suivant :

/ns(?=\d)/

où le "minlen" serait 3 mais "minlenret" ne serait que 2 car le \d est requis pour
correspond, mais n'est pas réellement inclus dans le contenu correspondant. Cette distinction est
particulièrement important car la logique de substitution utilise le "minlenret" pour dire si elle peut faire
substitutions sur place (celles-ci peuvent entraîner une accélération considérable).

"gof"
Décalage à gauche de pos () pour commencer le match à.

"substr"
Données de sous-chaîne sur les chaînes qui doivent apparaître dans la correspondance finale. C'est actuellement seulement
utilisé en interne par le moteur de Perl, mais pourrait être utilisé à l'avenir pour tous les moteurs pour
optimisations.

"nparens", "lastparen", et "derniercloseparent"
Ces champs sont utilisés pour garder une trace du nombre de groupes parent qui pourraient être appariés dans le
modèle, qui était la dernière parenthèse ouverte à entrer et qui était la dernière parenthèse fermée
être entré.

« intraflags »
La copie privée du moteur des drapeaux avec lesquels le modèle a été compilé. C'est généralement le
identique à "extflags" sauf si le moteur a choisi de modifier l'un d'entre eux.

"pprivé"
Un vide* pointant vers une structure de données définie par le moteur. Le moteur Perl utilise le
structure "regexp_internal" (voir "Structures de base" dans perlreguts) mais un moteur personnalisé
devrait utiliser autre chose.

"échange"
Inutilisé. Laissé pour compatibilité avec Perl 5.10.0.

"off"
Une structure "regexp_paren_pair" qui définit les décalages dans la chaîne à laquelle correspond
correspondent aux captures $& et $1, $2 etc., la structure "regexp_paren_pair" est définie
comme suit:

typedef struct regexp_paren_pair {
démarrage I32 ;
fin I32 ;
} regexp_paren_pair ;

Si "->offs[num].start" ou "->offs[num].end" est "-1", alors ce groupe de capture ne correspond pas.
"->offs[0].start/end" représente $& (ou "${^MATCH}" sous "//p") et "->offs[paren].end"
correspond à $$paren où $paren = 1>.

"précomp" "prélen"
Utilisé pour les optimisations. "precomp" contient une copie du modèle qui a été compilé et
"prelen" sa longueur. Lorsqu'un nouveau modèle doit être compilé (comme à l'intérieur d'une boucle), le
l'opérateur interne "regcomp" vérifie si le dernier "REGEXP" compilé est "precomp" et "prelen"
sont équivalents au nouveau, et si c'est le cas utilise l'ancien modèle au lieu de compiler un nouveau
une.

L'extrait pertinent de "Perl_pp_regcomp" :

if (!re || !re->precomp || re->prelen != (I32)len ||
memNE(re->precomp, t, len))
/* Compiler un nouveau modèle */

"paren_names"
Il s'agit d'un hachage utilisé en interne pour suivre les groupes de capture nommés et leurs décalages. Les clés
sont les noms des tampons les valeurs sont dualvars, avec le slot IV contenant le nombre
de tampons avec le nom donné et le pv étant un tableau intégré de I32. Les valeurs peuvent
également être contenus indépendamment dans le tableau de données dans les cas où des références arrière nommées sont
utilisé.

"substr"
Contient des informations sur la chaîne la plus longue qui doit se produire à un décalage fixe depuis le début
du modèle, et la chaîne la plus longue qui doit se produire à un décalage flottant depuis le début
du motif. Utilisé pour faire des recherches Fast-Boyer-Moore sur la chaîne pour savoir si son
Cela vaut la peine d'utiliser le moteur d'expression régulière, et si oui, où rechercher dans la chaîne.

"soumettre" "sublen" "copie_sauvegardée" "sous-décalage" "sous-coffre"
Utilisé pendant la phase d'exécution pour gérer les modèles de recherche et de remplacement, et pour
fournissant le texte pour $&, $1 etc. "subbeg" pointe vers un tampon (soit l'original
chaîne, ou une copie dans le cas de "RX_MATCH_COPIED(rx)"), et "sublen" est la longueur de la
amortir. Les index de début et de fin "RX_OFFS" indexent dans ce tampon.

En présence du drapeau "REXEC_COPY_STR", mais avec l'ajout du
Drapeaux "REXEC_COPY_SKIP_PRE" ou "REXEC_COPY_SKIP_POST", un moteur peut choisir de ne pas copier
le buffer plein (bien qu'il doive toujours le faire en présence de "RXf_PMf_KEEPCOPY" ou du
bits pertinents étant définis dans "PL_sawampersand"). Dans ce cas, il peut définir "sous-offset" sur
indiquer le nombre d'octets entre le début logique du tampon et le début physique
(c'est-à-dire "subbeg"). Il doit également définir "subcoffset", le nombre de caractères dans l'offset.
Ce dernier est nécessaire pour prendre en charge "@-" et "@+" qui fonctionnent en caractères, pas en octets.

"enveloppé" "envelopper"
Stocke la chaîne à laquelle "qr//" se rattache. Le moteur Perl stocke par exemple "(?^:eek)" dans
le cas de "qr/eek/".

Lors de l'utilisation d'un moteur personnalisé qui ne prend pas en charge la construction "(?:)" pour les modificateurs en ligne,
il est probablement préférable d'avoir "qr//" stringifié au modèle fourni, notez que cela
créer des motifs indésirables dans des cas tels que :

mon $x = qr/a|b/; # "a|b"
mon $y = qr/c/i; # "c"
mon $z = qr/$x$y/; # "a|bc"

Il n'y a pas de solution à ce problème autre que de faire comprendre au moteur personnalisé un
construire comme "(?:)".

"vu_evals"
Ceci stocke le nombre de groupes d'évaluation dans le modèle. Ceci est utilisé à des fins de sécurité
lors de l'intégration d'expressions régulières compilées dans des modèles plus grands avec "qr//".

"refnt"
Le nombre de fois où la structure est référencée. Lorsque cela tombe à 0, l'expression rationnelle est
libéré automatiquement par un appel à pregfree. Cela devrait être réglé sur 1 dans chaque moteur
routine "comp".

HISTOIRE

A l'origine partie de perlreguts.

AUTEURS

Écrit à l'origine par Yves Orton, développé par AEvar Arnfjoer` Bjarmason.

Utiliser perlreapi en ligne en utilisant les services onworks.net