perlreapi - Online na nuvem

PROGRAMA:

NOME

perlreapi - Interface de plugin de expressão regular Perl

DESCRIÇÃO

A partir do Perl 5.9.5, há uma nova interface para conectar e usar expressão regular
motores diferentes do padrão.

Cada mecanismo deve fornecer acesso a uma estrutura constante do seguinte formato:

typedef estrutura regexp_engine {
REGEXP * (* comp) (pTHX_
padrão const SV * const, sinalizadores const U32);
I32 (* exec) (pTHX_
REGEXP * const rx,
char * stringarg,
char * strend, char * strbeg,
SSize_t minend, SV * sv,
void * data, sinalizadores U32);
char * (* intuit) (pTHX_
REGEXP * const rx, SV * sv,
const char * const strbeg,
char * strpos, char * strend, sinalizadores U32,
struct re_scream_pos_data_s * data);
SV * (* checkstr) (pTHX_ REGEXP * const rx);
void (* livre) (pTHX_ REGEXP * const rx);
void (* numbered_buff_FETCH) (pTHX_
REGEXP * const rx,
const I32 parêntese,
SV * const SV);
void (* numbered_buff_STORE) (pTHX_
REGEXP * const rx,
const I32 parêntese,
SV const * valor const);
I32 (* numbered_buff_LENGTH) (pTHX_
REGEXP * const rx,
const SV * const SV,
const I32 parêntese);
SV * (* named_buff) (pTHX_
REGEXP * const rx,
SV * chave const,
Valor SV * const,
Sinalizadores U32);
SV * (* named_buff_iter) (pTHX_
REGEXP * const rx,
const SV * const última tecla,
sinalizadores const U32);
SV * (* qr_package) (pTHX_ REGEXP * const rx);
#ifdef USE_ITHREADS
void * (* dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS * param);
#fim se
REGEXP * (* op_comp) (...);

Quando um regexp é compilado, seu campo "motor" é então definido para apontar para o apropriado
estrutura, de modo que, quando for necessário, o Perl possa encontrar as rotinas certas para fazê-lo.

Para instalar um novo manipulador regexp, $ ^ H {regcomp} é definido como um inteiro que (quando
fundido apropriadamente) resolve para uma dessas estruturas. Ao compilar, o "comp"
método é executado, e espera-se que o campo do motor da estrutura "regexp" resultante
aponte para a mesma estrutura.

O símbolo pTHX_ na definição é uma macro usada por Perl em threading para fornecer um
argumento extra para a rotina que contém um ponteiro de volta para o interpretador que está executando
o regexp. Portanto, no encadeamento, todas as rotinas recebem um argumento extra.

Retornos de chamada

comp
REGEXP * comp (pTHX_ const padrão SV * const, sinalizadores const U32);

Compile o padrão armazenado em "padrão" usando os "sinalizadores" fornecidos e retorne um ponteiro para um
preparou a estrutura "REGEXP" que pode realizar a partida. Veja "A estrutura REGEXP" abaixo
para obter uma explicação dos campos individuais na estrutura REGEXP.

O parâmetro "padrão" é o escalar usado como padrão. Versões anteriores de
Perl passaria dois "char *" indicando o início e o fim do padrão stringificado; a
O seguinte snippet pode ser usado para obter os parâmetros antigos:

STRLEN Pleno;
char * exp = SvPV (padrão, plen);
char * xend = exp + plen;

Uma vez que qualquer escalar pode ser passado como um padrão, é possível implementar um motor que
faz algo com um array ("" ook "= ~ [qw / eek hlagh /]") ou com o não stringificado
forma de uma expressão regular compilada ("" ook "= ~ qr / eek /"). O próprio motor do Perl sempre
stringify tudo usando o trecho acima, mas isso não significa que outros motores precisam.

O parâmetro "flags" é um campo de bits que indica qual dos "msixpn" sinaliza o regex
foi compilado com. Ele também contém informações adicionais, como se "usar localidade" estiver em
efeito.

Os sinalizadores "eogc" são removidos antes de serem passados ​​para a rotina comp. O regex
o motor não precisa saber se algum deles está definido, pois esses sinalizadores devem afetar apenas
o que Perl faz com o padrão e suas variáveis ​​de correspondência, não como ele é compilado e
executado.

No momento em que o retorno de chamada comp é chamado, alguns desses sinalizadores já surtiram efeito
(anotado abaixo quando aplicável). No entanto, a maior parte de seu efeito ocorre após o comp.
callback foi executado, em rotinas que lêem o campo "rx-> extflags" que ele preenche.

Em geral, os sinalizadores devem ser preservados em "rx-> extflags" após a compilação, embora o
motor regex pode querer adicionar ou excluir alguns deles para invocar ou desabilitar alguns
comportamento em Perl. Os sinalizadores, juntamente com qualquer comportamento especial que causem, são documentados
abaixo:

Os modificadores de padrão:

"/ m" - RXf_PMf_MULTILINE
Se estiver em "rx-> extflags", será passado para "Perl_fbm_instr" por "pp_split" que
tratará a string em questão como uma string de várias linhas.

"/ s" - RXf_PMf_SINGLELINE
"/ i" - RXf_PMf_FOLD
"/ x" - RXf_PMf_EXTENDED
Se estiver presente em um regex, os comentários "#" serão tratados de maneira diferente pelo tokenizer em
alguns casos.

TODO: Documente esses casos.

"/ p" - RXf_PMf_KEEPCOPY
TODO: Documentar isto

Conjunto de caracteres
As regras do conjunto de caracteres são determinadas por um enum contido neste campo.
Isso ainda é experimental e sujeito a alterações, mas a interface atual retorna
as regras usando a função in-line "get_regex_charset (const U32 flags)". o
apenas o valor atualmente documentado retornado dele é REGEX_LOCALE_CHARSET, que é definido
se "usar localidade" estiver em vigor. Se estiver presente em "rx-> extflags", "split" usará o
definição dependente de local de espaço em branco quando RXf_SKIPWHITE ou RXf_WHITE está em
efeito. O espaço em branco ASCII é definido como por isSPACE e pelas macros internas
"is_utf8_space" em UTF-8 e "isSPACE_LC" em "usar localidade".

Sinalizadores adicionais:

RXf_SPLIT
Este sinalizador foi removido no perl 5.18.0. "split ''" agora é especial apenas no
analisador. RXf_SPLIT ainda está #defined, então você pode testá-lo. É assim que costumava
trabalhos:

Se "divisão" for invocado como "divisão ''" ou sem argumentos (o que realmente significa "divisão ('
', $ _) ", veja divisão), Perl irá definir este sinalizador. O motor regex pode então verificar por ele
e definir os extflags SKIPWHITE e WHITE. Para fazer isso, o mecanismo Perl faz:

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

Esses sinalizadores podem ser definidos durante a compilação para permitir otimizações no operador "split".

RXf_SKIPWHITE
Este sinalizador foi removido no perl 5.18.0. Ainda está #definido, então você pode configurá-lo, mas
fazer isso não terá efeito. É assim que costumava funcionar:

Se o sinalizador estiver presente em "rx-> extflags" "split" irá deletar os espaços em branco do início
da string em questão antes de ser operada. O que é considerado espaço em branco depende
ativado se o assunto é uma string UTF-8 e se o sinalizador "RXf_PMf_LOCALE" está definido.

Se RXf_WHITE for definido além deste sinalizador, "dividir" se comportará como "dividir" ""
sob o motor Perl.

RXf_START_ONLY
Diz ao operador de divisão para dividir a string de destino em novas linhas ("\ n") sem
invocando o mecanismo regex.

O motor do Perl define isso se o padrão for "/ ^ /" ("plen == 1 && * exp == '^'"), mesmo
sob "/ ^ / s"; veja a divisão. Claro, um motor regex diferente pode querer usar o
mesmas otimizações com uma sintaxe diferente.

RXf_BRANCO
Diz ao operador de divisão para dividir a string de destino em um espaço em branco sem invocar o
motor regex. A definição de espaço em branco varia dependendo se a string de destino
é uma string UTF-8 e ativada se RXf_PMf_LOCALE estiver definido.

O motor do Perl define este sinalizador se o padrão for "\ s +".

RXf_NULL
Diz ao operador de divisão para dividir a string de destino em caracteres. A definição de
O caractere varia dependendo se a string de destino é uma string UTF-8.

O motor do Perl define este sinalizador em padrões vazios, esta otimização torna "dividir //"
muito mais rápido do que seria de outra forma. É ainda mais rápido do que "desempacotar".

RXf_NO_INPLACE_SUBST
Adicionado em perl 5.18.0, este sinalizador indica que uma expressão regular pode realizar um
operação que interferiria com a substituição local. Por exemplo, pode
contêm lookbehind ou atribuem a variáveis ​​não mágicas (como $ REGMARK e
$ REGERROR) durante a correspondência. "s ///" irá pular certas otimizações quando isto for definido.

exec
I32 exec (pTHX_ REGEXP * const rx,
char * stringarg, char * strend, char * strbeg,
SSize_t minend, SV * sv,
void * data, sinalizadores U32);

Execute uma regexp. Os argumentos são

rx A expressão regular a ser executada.

sv Este é o SV a ser comparado. Observe que a matriz real de char a ser correspondida
contra é fornecido pelos argumentos descritos abaixo; o SV é usado apenas para determinar
UTF8ness, "pos ()" etc.

strbeg
Ponteiro para o início físico da string.

esforçar
Ponteiro para o caractere após o final físico da string (ou seja, o "\ 0", se
algum).

stringarg
Ponteiro para a posição na string onde a correspondência deve começar; pode não ser
igual a "strbeg" (por exemplo, em uma iteração posterior de "/.../g").

mina
Comprimento mínimo da string (medido em bytes de "stringarg") que deve corresponder; se o
motor chega ao final da partida, mas não atingiu esta posição na string,
deve falhar.

dados,
Dados de otimização; sujeito a mudanças.

bandeiras
Sinalizadores de otimização; sujeito a mudanças.

intuir
char * intuit (pTHX_
REGEXP * const rx,
SV * sv,
const char * const strbeg,
char * strpos,
char * strend,
sinalizadores const U32,
struct re_scream_pos_data_s * data);

Encontre a posição inicial onde uma correspondência de regex deve ser tentada, ou possivelmente se o regex
o motor não deve ser executado porque o padrão não pode corresponder. Isso é chamado, conforme apropriado,
pelo núcleo, dependendo dos valores do membro "extflags" da estrutura "regexp".

Argumentos:

rx: a regex a ser comparada
sv: o SV sendo combinado: usado apenas para a bandeira utf8; a corda
em si é acessado por meio dos ponteiros abaixo. Observe que em
algo como um SV sobrecarregado, SvPOK (sv) pode ser falso
e os ponteiros de string podem apontar para algo não relacionado a
o próprio SV.
strbeg: verdadeiro começo da corda
strpos: o ponto na string em que iniciar a correspondência
strend: ponteiro para o byte após o último caractere da string
sinalizadores atualmente não utilizados; definido como 0
dados: atualmente não utilizados; definido como NULL

checkstr
SV * checkstr (pTHX_ REGEXP * const rx);

Retorne um SV contendo uma string que deve aparecer no padrão. Usado por "dividir" para
otimizar correspondências.

sem
void free (pTHX_ REGEXP * const rx);

Chamado por Perl quando está liberando um padrão regexp para que o mecanismo possa liberar qualquer
recursos apontados pelo membro "pprivate" da estrutura "regexp". Este é apenas
responsável por liberar dados privados; Perl irá lidar com a liberação de qualquer outra coisa contida
na estrutura "regexp".

numerada capturar retornos de chamada
Chamado para obter / definir o valor de "$` "," $ '", $ & e seus equivalentes nomeados, $ {^ PREMATCH},
$ {^ POSTMATCH} e $ {^ MATCH}, bem como os grupos de captura numerados ($ 1, $ 2, ...).

O parâmetro "parentesco" será 1 para $ 1, 2 para $ 2 e assim por diante, e terá estes
valores para as variáveis ​​especiais:

$ {^ 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

Observe que no Perl 5.17.3 e anteriores, as últimas três constantes também foram usadas para o
variantes de acento circunflexo das variáveis.

Os nomes foram escolhidos por analogia com Tie :: nomes de métodos escalares com um adicional
COMPRIMENTO retorno de chamada para eficiência. No entanto, as variáveis ​​de captura nomeadas atualmente não estão vinculadas
internamente, mas implementado via mágica.

number_buff_FETCH

void numbered_buff_FETCH (pTHX_ REGEXP * const rx, const I32 parênteses,
SV * const SV);

Busque uma captura numerada especificada. "sv" deve ser definido como o escalar para retornar, o
escalar é passado como um argumento em vez de ser retornado da função porque quando
é chamado de Perl já tem um escalar para armazenar o valor, criar outro seria
redundante. O escalar pode ser definido com "sv_setsv", "sv_setpvn" e amigos, veja perlapi.

Este callback é onde o Perl limpa suas próprias variáveis ​​de captura sob o modo de contaminação (veja
perlsec). Veja a função "Perl_reg_numbered_buff_fetch" em regcomp.c para saber como desmanchar
capturar variáveis ​​se isso for algo que você gostaria que seu mecanismo também fizesse.

numerado_buff_STORE

void (* numbered_buff_STORE) (pTHX_
REGEXP * const rx,
const I32 parêntese,
SV const * valor const);

Defina o valor de uma variável de captura numerada. "valor" é o escalar que deve ser usado como
o novo valor. Cabe ao motor garantir que isso seja usado como o novo valor (ou
rejeitá-lo).

Exemplo:

if ("ook" = ~ / (o *) /) {
# 'parênteses' será '1' e 'valor' será 'ee'
$ 1 = ~ tr / o / e /;
}

O próprio motor do Perl irá coaxar em qualquer tentativa de modificar as variáveis ​​de captura, para fazer isso em
outro mecanismo usa o seguinte retorno de chamada (copiado de "Perl_reg_numbered_buff_store"):

anular
Example_reg_numbered_buff_store (pTHX_
REGEXP * const rx,
const I32 parêntese,
SV const * valor const)
{
PERL_UNUSED_ARG (rx);
PERL_UNUSED_ARG (parênteses);
PERL_UNUSED_ARG (valor);

if (! PL_localizing)
Perl_croak (aTHX_ PL_no_modify);
}

Na verdade, Perl não vai sempre coaxar em uma declaração que parece que modificaria um
variável de captura numerada. Isso ocorre porque o retorno de chamada STORE não será chamado se Perl
pode determinar que não é necessário modificar o valor. É exatamente assim que amarrado
variáveis ​​se comportam na mesma situação:

pacote CaptureVar;
use o pai 'Tie :: Scalar';

sub TIESCALAR {abençoar []}
sub FETCH {undef}
sub STORE {die "Isso não é chamado de"}

pacote principal;

amarrar minha $ sv => "CaptureVar";
$ sv = ~ y / a / b /;

Porque $ sv é "undef" quando o operador "y ///" é aplicado a ele, a transliteração
não será executado e o programa não "morrerá". Isso é diferente de como 5.8 e
versões anteriores se comportavam porque as variáveis ​​de captura eram variáveis ​​READONLY; agora
eles simplesmente morrerão quando atribuídos no mecanismo padrão.

number_buff_LENGTH

I32 numerado_buff_LENGTH (pTHX_
REGEXP * const rx,
const SV * const SV,
const I32 parêntese);

Obtenha o "comprimento" de uma variável de captura. Há um retorno de chamada especial para isso, para que Perl
não tem que fazer um FETCH e executar "length" no resultado, uma vez que o comprimento é (em Perl's
caso) conhecido a partir de um deslocamento armazenado em "rx-> offs", isso é muito mais eficiente:

I32 s1 = rx-> offs [parênteses]. Iniciar;
I32 s2 = rx-> offs [parênteses] .end;
I32len = t1 - s1;

Isso é um pouco mais complexo no caso do UTF-8, veja o que
"Perl_reg_numbered_buff_length" faz com is_utf8_string_loclen.

Nomeado capturar retornos de chamada
Chamado para obter / definir o valor de "% +" e "% -", bem como por algumas funções utilitárias em re.

Existem dois retornos de chamada, "named_buff" é chamado em todos os casos de FETCH, STORE, DELETE,
CLEAR, EXISTS e SCALAR Tie :: Hash callbacks estariam em mudanças para "% +" e "% -" e
"named_buff_iter" nos mesmos casos que FIRSTKEY e NEXTKEY.

O parâmetro "sinalizadores" pode ser usado para determinar quais dessas operações os retornos de chamada
deve responder. Os seguintes sinalizadores estão definidos atualmente:

Qual operação Tie :: Hash está sendo realizada a partir do nível Perl em "% +" ou "% +", se houver:

RXapif_FETCH
RXapif_STORE
RXapif_DELETE
RXapif_CLEAR
RXapif_EXISTS
RXapif_SCALAR
RXapif_FIRSTKEY
RXapif_NEXTKEY

Se "% +" ou "% -" estiver sendo operado, se houver.

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

Se estiver sendo chamado como "re :: regname", "re :: regnames" ou "re :: regnames_count", se houver.
Os dois primeiros serão combinados com "RXapif_ONE" ou "RXapif_ALL".

RXapif_REGNAME
RXapif_REGNAMES
RXapif_REGNAMES_COUNT

Internamente, "% +" e "% -" são implementados com uma interface real vinculada por meio de
Tie :: Hash :: NamedCapture. Os métodos nesse pacote irão chamar de volta para essas funções.
No entanto, o uso de Tie :: Hash :: NamedCapture para esta finalidade pode mudar no futuro
lançamentos. Por exemplo, isso pode ser implementado por mágica em vez disso (precisaria de um
extensão para mgvtbl).

name_buff

SV * (* named_buff) (pTHX_ REGEXP * const rx, SV * chave const,
SV * valor const, sinalizadores U32);

nomeado_buff_iter

SV * (* named_buff_iter) (pTHX_
REGEXP * const rx,
const SV * const última tecla,
sinalizadores const U32);

pacote_qr
SV * qr_package (pTHX_ REGEXP * const rx);

O pacote em que o objeto mágico qr // é abençoado (como visto por "ref qr //"). Isto é
recomendado que os motores mudem isso para seu nome de pacote para identificação, independentemente
de se eles implementam métodos no objeto.

O pacote que este método retorna também deve ter o pacote interno "Regexp" em seu
@É UM. "qr // -> isa (" Regexp ")" deve ser sempre verdadeiro, independentemente de qual motor está sendo
usava.

Implementação de exemplo pode ser:

SV *
Exemplo_qr_package (pTHX_ REGEXP * const rx)
{
PERL_UNUSED_ARG (rx);
return newSVpvs ("re :: engine :: Exemplo");
}

Qualquer chamada de método em um objeto criado com "qr //" será despachada para o pacote como um
objeto normal.

use re :: engine :: Example;
meu $ re = qr //;
$ re-> meth; # despachado para re :: engine :: Example :: meth ()

Para recuperar o objeto "REGEXP" do escalar em uma função XS, use a macro "SvRX",
consulte "Funções REGEXP" em perlapi.

void meth (SV * rv)
CÓDIGO PP:
REGEXP * re = SvRX (sv);

joguete
void * dupe (pTHX_ REGEXP * const rx, CLONE_PARAMS * param);

Em compilações encadeadas, um regexp pode precisar ser duplicado para que o padrão possa ser usado por
vários tópicos. Espera-se que esta rotina lide com a duplicação de quaisquer dados privados
apontado pelo membro "pprivate" da estrutura "regexp". Será chamado com o
nova estrutura "regexp" pré-construída como um argumento, o membro "pprivate" apontará para
da velho estrutura privada, e é responsabilidade dessa rotina construir uma cópia e
retorna um ponteiro para ele (que o Perl irá então usar para sobrescrever o campo como passado para este
rotina.)

Isso permite que o mecanismo engane seus dados privados, mas também, se necessário, modifique o
estrutura se realmente deve.

Em compilações não encadeadas, este campo não existe.

op_comp
Isso é privado para o núcleo Perl e está sujeito a alterações. Deve ser deixado nulo.

A REGEXP estrutura

A estrutura REGEXP é definida em regexp.h. Todos os motores de regex devem ser capazes de
construir tal estrutura em sua rotina "comp".

A estrutura REGEXP contém todos os dados que o Perl precisa estar ciente para funcionar corretamente
com a expressão regular. Inclui dados sobre otimizações que Perl pode usar para
determinar se o motor regex deve realmente ser usado, e várias outras informações de controle que
é necessário para executar padrões em vários contextos, como se o padrão
ancorado de alguma forma, ou quais sinalizadores foram usados ​​durante a compilação, ou se o programa
contém construções especiais das quais o Perl precisa estar ciente.

Além disso, contém dois campos que se destinam ao uso privado do regex
motor que compilou o padrão. Esses são os membros "intflags" e "pprivate".
"pprivate" é um indicador vazio para uma estrutura arbitrária, cujo uso e gerenciamento é o
responsabilidade do motor de compilação. O Perl nunca modificará nenhum desses valores.

typedef estrutura regexp {
/ * qual mecanismo criou este regexp? * /
const struct regexp_engine * engine;

/ * de que esta é uma cópia leve? * /
struct regexp * mother_re;

/ * Informações sobre a correspondência que o núcleo Perl usa para gerenciar
* coisas */
Extflags U32; / * Sinalizadores usados ​​externamente e internamente * /
I32 minlen; / * número mínimo possível de caracteres em * /
string para corresponder a * /
I32 minlenret; / * número mínimo possível de caracteres em $ & * /
U32 gofs; / * caracteres à esquerda da posição que pesquisamos * /

/ * dados de substring sobre strings que devem aparecer
na partida final, usado para otimizações * /
struct reg_substr_data * substrs;

U32 nparens; / * número de grupos de captura * /

/ * dados específicos do mecanismo privado * /
U32 intflags; / * Sinalizadores internos específicos do mecanismo * /
void * pprivate; / * Dados privados para o mecanismo regex que
criou este objeto. * /

/ * Dados sobre a última / atual correspondência. Estes são modificados durante
* Coincidindo*/
U32 lastparen; / * parênteses de fechamento mais altos correspondentes ($ +) * /
U32 lastcloseparen; / * último parênteses de fechamento correspondido ($ ^ N) * /
regexp_paren_pair * swap; / * Trocar cópia de * offs * /
regexp_paren_pair * offs; / * Matriz de deslocamentos para (@ -) e
(@ +) * /

char * subbeg; / * string salva ou original para que \ digit funcione
para sempre. * /
SV_SAVED_COPY / * Se não NULL, SV que é COW do original * /
I32 sublen; / * Comprimento da string apontada por subbeg * /
Suboffset I32; / * deslocamento de byte do subbeg do início lógico de
str * /
Subcoffset I32; / * suboffset equiv, mas em caracteres (para @ - / @ +) * /

/ * Informações sobre a correspondência que não costumam ser usadas * /
I32 prelen; / * comprimento do pré-comp. * /
const char * precomp; / * expressão regular de pré-compilação * /

char * embalado; / * versão encapsulada do padrão * /
I32 wraplen; / * comprimento da embalagem * /

I32 seen_evals; / * número de grupos de avaliação no padrão - para
verificações de segurança * /
HV * paren_names; / * Hash opcional de nomes de parênteses * /

/ * Refcount deste regexp * /
I32 refcnt; / * Refcount deste regexp * /
} expressão regular;

Os campos são discutidos em mais detalhes abaixo:

"motor"
Este campo aponta para uma estrutura "regexp_engine" que contém ponteiros para o
sub-rotinas que devem ser usadas para realizar uma correspondência. É a rotina de compilação
responsabilidade de preencher este campo antes de retornar o objeto regexp.

Internamente, é definido como "NULL", a menos que um mecanismo personalizado seja especificado em $ ^ H {regcomp},
O próprio conjunto de callbacks do Perl pode ser acessado na estrutura apontada por "RE_ENGINE_PTR".

"mãe_re"
TODO, vejahttp://www.mail-archive.com/perl5-changes@ perl.org / msg17328.html>

"extflags"
Isso será usado pelo Perl para ver com quais sinalizadores o regexp foi compilado.
normalmente é definido com o valor do parâmetro flags pelo retorno de chamada comp. Veja o comp
documentação para sinalizadores válidos.

"minlen" "minlenret"
O comprimento mínimo da string (em caracteres) necessário para que o padrão corresponda. Isso é usado
para podar o espaço de busca, não se preocupando em combinar mais perto do final de uma corda do que
permitiria uma correspondência. Por exemplo, não há nenhum ponto em até mesmo iniciar o mecanismo de regex se
o minlen é 10, mas a string tem apenas 5 caracteres. Não há como o
padrão pode corresponder.

"minlenret" é o comprimento mínimo (em caracteres) da string que seria encontrada em $ &
depois de uma partida.

A diferença entre "minlen" e "minlenret" pode ser vista no seguinte padrão:

/ ns (? = \ d) /

onde o "minlen" seria 3, mas "minlenret" seria apenas 2, pois o \ d é necessário para
corresponder, mas não está realmente incluído no conteúdo correspondido. Esta distinção é
particularmente importante porque a lógica de substituição usa o "minlenret" para dizer se ele pode fazer
substituições no local (podem resultar em considerável aceleração).

"gofs"
Deslocamento à esquerda de pos () para começar a partida em.

"substrs"
Dados de substring sobre strings que devem aparecer na correspondência final. Atualmente é apenas
usado internamente pelo motor do Perl, mas pode ser usado no futuro para todos os motores para
otimizações.

"nparens", "lastparen", e "lastcloseparen"
Esses campos são usados ​​para controlar quantos grupos de pais podem ser combinados no
padrão, que foi o último parêntese aberto a ser inserido e qual foi o último parêntese fechado
para ser inserido.

"intflags"
A cópia privada do mecanismo dos sinalizadores com os quais o padrão foi compilado. Normalmente este é o
mesmo que "extflags", a menos que o mecanismo opte por modificar um deles.

"privado"
Um vazio * apontando para uma estrutura de dados definida pelo mecanismo. O motor Perl usa o
estrutura "regexp_internal" (consulte "Estruturas de base" em perlreguts), mas um mecanismo personalizado
deve usar outra coisa.

"troca"
Não utilizado. Deixado para compatibilidade com Perl 5.10.0.

"offs"
Uma estrutura "regexp_paren_pair" que define deslocamentos para a string a ser correspondida que
correspondem às capturas $ & e $ 1, $ 2 etc., a estrutura "regexp_paren_pair" é definida
como se segue:

typedef estrutura regexp_paren_pair {
I32 iniciar;
Fim I32;
} regexp_paren_pair;

Se "-> offs [num] .start" ou "-> offs [num] .end" for "-1", então esse grupo de captura não correspondeu.
"-> offs [0]. start / end" representa $ & (ou "$ {^ MATCH}" em "// p") e "-> offs [parênteses].
corresponde a $$ parênteses onde $ parênteses = 1>.

"pré-comp" "prelen"
Usado para otimizações. "pré-comp" contém uma cópia do padrão que foi compilado e
"prelen" seu comprimento. Quando um novo padrão deve ser compilado (como dentro de um loop), o
O operador interno "regcomp" verifica se o último "REGEXP" compilado "precomp" e "prelen"
são equivalentes ao novo, e se assim for, usa o padrão antigo em vez de compilar um novo
um.

O snippet relevante de "Perl_pp_regcomp":

if (! re ||! re-> precomp || re> prelen! = (I32) len ||
memNE (re-> pré-comp, t, len))
/ * Compile um novo padrão * /

"paren_names"
Este é um hash usado internamente para rastrear grupos de captura nomeados e seus deslocamentos. As chaves
são os nomes dos buffers, os valores são dualvars, com o slot IV contendo o número
de buffers com o nome fornecido e o pv sendo uma matriz incorporada de I32. Os valores podem
também estar contido de forma independente na matriz de dados nos casos em que as referências anteriores são
usava.

"substrs"
Contém informações sobre a string mais longa que deve ocorrer em um deslocamento fixo desde o início
do padrão, e a string mais longa que deve ocorrer em um deslocamento flutuante desde o início
do padrão. Costumava fazer pesquisas Fast-Boyer-Moore na string para descobrir se
vale a pena usar o mecanismo de regex e, se for o caso, onde pesquisar na string.

"subbeg" "sublen" "saved_copy" "suboffset" "subcoffset"
Usado durante a fase de execução para gerenciar padrões de pesquisa e substituição e para
fornecendo o texto para $ &, $ 1 etc. "subbeg" aponta para um buffer (seja o original
string, ou uma cópia no caso de "RX_MATCH_COPIED (rx)"), e "sublen" é o comprimento do
amortecedor. O índice de índices inicial e final "RX_OFFS" neste buffer.

Na presença do sinalizador "REXEC_COPY_STR", mas com a adição do
Sinalizadores "REXEC_COPY_SKIP_PRE" ou "REXEC_COPY_SKIP_POST", um mecanismo pode escolher não copiar
o buffer cheio (embora ainda deva fazê-lo na presença de "RXf_PMf_KEEPCOPY" ou o
bits relevantes sendo definidos em "PL_sawampersand"). Neste caso, pode definir "suboffset" para
indica o número de bytes desde o início lógico do buffer até o início físico
(ou seja, "subbeg"). Ele também deve definir "subcoffset", o número de caracteres no deslocamento.
O último é necessário para suportar "@ -" e "@ +", que funcionam em caracteres, não em bytes.

"envolto" "embrulhar"
Armazena a string "qr //" como string. O mecanismo Perl, por exemplo, armazena "(? ^: Eek)" em
o caso de "qr / eek /".

Ao usar um mecanismo personalizado que não suporta a construção "(? :)" para modificadores embutidos,
provavelmente é melhor ter "qr //" stringify para o padrão fornecido, observe que isso irá
criar padrões indesejados em casos como:

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

Não há solução para esse problema além de fazer o mecanismo personalizado entender um
construir como "(? :)".

"seen_evals"
Isso armazena o número de grupos de avaliação no padrão. Isso é usado para fins de segurança
ao incorporar regexes compiladas em padrões maiores com "qr //".

"refcnt"
O número de vezes que a estrutura é referenciada. Quando cai para 0, o regexp é
liberado automaticamente por uma chamada para pré-livre. Isso deve ser definido como 1 em cada motor
rotina "comp".

HISTÓRIA

Originalmente parte do perlreguts.

AUTORES

Originalmente escrito por Yves Orton, expandido por AEvar Arnfjoer` Bjarmason.

Use perlreapi online usando serviços onworks.net