perlapi - Online na nuvem

PROGRAMA:

NOME

perlapi - documentação gerada automaticamente para a API perl pública

DESCRIÇÃO

Este arquivo contém a documentação da API perl pública gerada por incorporar.pl,
especificamente uma lista de funções, macros, sinalizadores e variáveis ​​que podem ser usados ​​por
escritores de extensão. No final, há uma lista de funções que ainda não foram documentadas.
As interfaces desses estão sujeitas a alterações sem aviso prévio. Qualquer coisa não listada aqui é
não faz parte da API pública e não deve ser usado por escritores de extensão. Para estes
razões, cegamente usar funções listadas em proto.h deve ser evitado ao escrever
extensões.

Observe que todas as variáveis ​​globais da API Perl devem ser referenciadas com o prefixo "PL_". Novamente,
aqueles não listados aqui não devem ser usados ​​por escritores de extensão e podem ser alterados ou
removido sem aviso prévio; mesmo com macros. Algumas macros são fornecidas para compatibilidade com
os nomes mais antigos e sem adornos, mas esse suporte pode ser desativado em uma versão futura.

Perl foi originalmente escrito para lidar apenas com US-ASCII (ou seja, caracteres cujo ordinal
números estão no intervalo de 0 a 127). E a documentação e os comentários ainda podem usar o termo
ASCII, quando às vezes de fato todo o intervalo de 0 a 255 é usado.

Observe que Perl pode ser compilado e executado em ASCII ou EBCDIC (consulte perlebcdic).
A maior parte da documentação (e até comentários no código) ignora a possibilidade de EBCDIC.
Para quase todos os propósitos, as diferenças são transparentes. Por exemplo, sob EBCDIC,
em vez de UTF-8, UTF-EBCDIC é usado para codificar strings Unicode e, portanto, sempre que este
a documentação refere-se a "utf8" (e variantes desse nome, incluindo em nomes de funções),
também (essencialmente de forma transparente) significa "UTF-EBCDIC". Mas os ordinais dos caracteres
diferem entre as codificações ASCII, EBCDIC e UTF-, e uma string codificada em UTF-EBCDIC
pode ocupar mais bytes do que em UTF-8.

A lista abaixo está em ordem alfabética, sem distinção entre maiúsculas e minúsculas.

"Gimme" Valores

GIMME Uma versão compatível com versões anteriores de "GIMME_V" que só pode retornar "G_SCALAR" ou
"G_ARRAY"; em um contexto vazio, ele retorna "G_SCALAR". Descontinuada. Use "GIMME_V"
ao invés.

U32 ME DÁ

GIMME_V O equivalente do gravador XSUB ao "wantarray" do Perl. Retorna "G_VOID", "G_SCALAR"
ou "G_ARRAY" para contexto vazio, escalar ou de lista, respectivamente. Veja perlcall para um
exemplo de uso.

U32 GIMME_V

G_ARRAY Usado para indicar o contexto da lista. Veja "GIMME_V", "GIMME" e perlcall.

G_DISCARD
Indica que os argumentos retornados de um retorno de chamada devem ser descartados. Ver
perlcall.

G_EVAL Usado para forçar um wrapper "eval" Perl em torno de um retorno de chamada. Veja perlcall.

G_NOARGS
Indica que nenhum argumento está sendo enviado para um retorno de chamada. Veja perlcall.

G_ESCALAR
Usado para indicar contexto escalar. Veja "GIMME_V", "GIMME" e perlcall.

G_VOID Usado para indicar o contexto vazio. Veja "GIMME_V" e perlcall.

Ordem Manipulação Funções

AvFILL O mesmo que "av_top_index ()". Obsoleto, use "av_top_index ()" ao invés.

int AvFILL (AV * av)

av_clear
Libera todos os elementos de um array, deixando-o vazio. O equivalente XS de
"@array = ()". Veja também "av_undef".

Observe que é possível que as ações de um destruidor sejam chamadas diretamente ou
indiretamente, ao liberar um elemento da matriz, pode causar a contagem de referência de
a própria matriz a ser reduzida (por exemplo, excluindo uma entrada na tabela de símbolos). Então
é uma possibilidade de que o AV possa ter sido liberado (ou mesmo realocado) em
retornar da chamada, a menos que você mantenha uma referência a ele.

void av_clear (AV * av)

av_create_and_push
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Empurre um SV para o final do array, criando o array se necessário. Um pequeno
função auxiliar interna para remover um idioma comumente duplicado.

void av_create_and_push (AV ** const avp,
SV * const val)

av_create_and_unshift_one
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Desfaz o deslocamento de um SV para o início do array, criando o array se necessário.
Uma pequena função auxiliar interna para remover um idioma comumente duplicado.

SV ** av_create_and_unshift_one (AV ** const avp,
SV * const val)

av_delete
Exclui o elemento indexado por "chave" da matriz, torna o elemento mortal e
retorna. Se "flags" for igual a "G_DISCARD", o elemento é liberado e nulo é
retornou. Equivalente em Perl: "my $ elem = delete ($ myarray [$ idx]);" para o
versão não "G_DISCARD" e um contexto vazio "delete ($ myarray [$ idx]);" para o
Versão "G_DISCARD".

SV * av_delete (AV * av, chave SSize_t, sinalizadores I32)

av_existe
Retorna verdadeiro se o elemento indexado por "chave" foi inicializado.

Isso se baseia no fato de que os elementos da matriz não inicializados são definidos como NULL.

Equivalente em Perl: "existe ($ myarray [$ key])".

bool av_exists (AV * av, chave SSize_t)

av_extend
Pré-estenda uma matriz. A "chave" é o índice para o qual a matriz deve ser
estendido.

void av_extend (AV * av, chave SSize_t)

av_fetch
Retorna o SV no índice especificado na matriz. A "chave" é o índice. Se
lval é verdade, você tem a garantia de receber um SV real de volta (no caso de não ser real
antes), que você pode modificar. Verifique se o valor de retorno não é nulo
antes de desreferenciá-lo para um "SV *".

Consulte "Compreendendo a magia de Hashes e matrizes amarrados" em perlguts para obter mais
informações sobre como usar esta função em matrizes vinculadas.

O equivalente aproximado em perl é $ myarray [$ idx].

SV ** av_fetch (AV * av, chave SSize_t, I32 lval)

av_fill Define o índice mais alto na matriz para o número fornecido, equivalente ao de Perl
"$ # array = $ fill;".

O número de elementos na matriz será "preenchimento + 1" após av_fill () retorna.
Se a matriz era mais curta anteriormente, os elementos adicionais anexados são definidos
para NULL. Se a matriz for mais longa, os elementos excedentes serão liberados.
"av_fill (av, -1)" é o mesmo que "av_clear (av)".

void av_fill (AV * av, SSize_t fill)

av_len O mesmo que "av_top_index". Observe que, ao contrário do que o nome indica, ele retorna o
índice mais alto na matriz, portanto, para obter o tamanho da matriz, você precisa usar
"av_len (av) + 1". É diferente de "sv_len", que retorna o que você esperaria.

SSize_t av_len (AV * av)

av_make Cria um novo AV e o preenche com uma lista de SVs. Os SVs são copiados para o
array, então eles podem ser liberados após a chamada para av_make. O novo AV terá um
contagem de referência de 1.

Equivalente em Perl: "meu @new_array = ($ scalar1, $ scalar2, $ scalar3 ...);"

AV * av_make (tamanho SSize_t, SV ** strp)

av_pop Remove um SV do final da matriz, reduzindo seu tamanho em um e retornando
o SV (transferindo o controle de uma contagem de referência) para o chamador. Devoluções
& PL_sv_undef se a matriz estiver vazia.

Equivalente em Perl: "pop (@myarray);"

SV * av_pop (AV * av)

av_push Empurra um SV para o final da matriz. A matriz aumentará automaticamente para
acomodar a adição. Isso assume a propriedade de uma contagem de referência.

Equivalente em Perl: "push @myarray, $ elem;".

void av_push (AV * av, SV * val)

av_shift
Remove um SV do início da matriz, reduzindo seu tamanho em um e retornando
o SV (transferindo o controle de uma contagem de referência) para o chamador. Devoluções
& PL_sv_undef se a matriz estiver vazia.

Equivalente em Perl: "shift (@myarray);"

SV * av_shift (AV * av)

av_store
Armazena um SV em uma matriz. O índice da matriz é especificado como "chave". O retorno
o valor será NULL se a operação falhou ou se o valor não precisava ser
realmente armazenado dentro da matriz (como no caso de matrizes vinculadas). Caso contrário isto
pode ser desreferenciado para obter o "SV *" que foi armazenado lá (= "val")).

Observe que o chamador é responsável por incrementar adequadamente a contagem de referência
de "val" antes da chamada e diminuindo-o se a função retornou NULL.

Equivalente aproximado em Perl: "$ myarray [$ key] = $ val;".

Consulte "Compreendendo a magia de Hashes e matrizes amarrados" em perlguts para obter mais
informações sobre como usar esta função em matrizes vinculadas.

SV ** av_store (AV * av, chave SSize_t, SV * val)

av_tindex
O mesmo que "av_top_index ()".

int av_tindex (AV * av)

av_top_index
Retorna o índice mais alto da matriz. O número de elementos na matriz é
"av_top_index (av) + 1". Retorna -1 se a matriz estiver vazia.

O equivalente em Perl para isso é $ # myarray.

(Uma forma um pouco mais curta é "av_tindex".)

SSize_t av_top_index (AV * av)

av_undef
Indefine a matriz. O equivalente XS de "undef (@array)".

Além de liberar todos os elementos da matriz (como "av_clear ()"), isso também
libera a memória usada pelo av para armazenar sua lista de escalares.

Veja "av_clear" para uma nota sobre o array possivelmente ser inválido no retorno.

void av_undef (AV * av)

av_unshift
Desfaça o deslocamento do número fornecido de valores "undef" para o início da matriz. o
array crescerá automaticamente para acomodar a adição. Você deve então usar
"av_store" para atribuir valores a esses novos elementos.

Equivalente em Perl: "unshift @myarray, ((undef) x $ n);"

void av_unshift (AV * av, SSize_t num)

get_av Retorna o AV do global Perl especificado ou array de pacotes com o nome dado
(por isso não funcionará em variáveis ​​lexicais). "sinalizadores" são passados ​​para "gv_fetchpv". Se
"GV_ADD" é definido e a variável Perl não existe, então ela será criada. Se
"flags" é zero e a variável não existe, então NULL é retornado.

Equivalente Perl: "@ {" $ name "}".

NOTA: a forma perl_ desta função está obsoleta.

AV * get_av (const char * name, I32 flags)

newAV Cria um novo AV. A contagem de referência é definida como 1.

Equivalente em Perl: "meu @array;".

AV * newAV ()

sortsv Classifica uma matriz. Aqui está um exemplo:

sortsv (AvARRAY (av), av_top_index (av) +1, Perl_sv_cmp_locale);

Atualmente, sempre usa mergesort. Veja sortsv_flags para um mais flexível
rotina.

void sortsv (SV ** array, size_t num_elts,
SVCOMPARE_t cmp)

sortsv_flags
Classifique uma matriz, com várias opções.

void sortsv_flags (SV ** array, size_t num_elts,
SVCOMPARE_t cmp, sinalizadores U32)

"xsubpp" variáveis e interno funções

A variável ax que é configurada por "xsubpp" para indicar o deslocamento da base da pilha, usado pelo
Macros "ST", "XSprePUSH" e "XSRETURN". A macro "dMARK" deve ser chamada antes
para configurar a variável "MARK".

Machado I32

Variável de CLASSE que é configurada por "xsubpp" para indicar o nome da classe para um C ++ XS
construtor. É sempre um "char *". Veja isso".

char * CLASS

dAX Configura a variável "ax". Isso geralmente é tratado automaticamente por "xsubpp" por
chamando "dXSARGS".

dAX;

dAXMARK Configura a variável "ax" e a variável "mark" do marcador de pilha. Isso geralmente é
tratado automaticamente por "xsubpp" chamando "dXSARGS".

DAXMARK;

dITEMS Configura a variável "itens". Isso geralmente é tratado automaticamente por "xsubpp"
chamando "dXSARGS".

dITEMS;

dUNDERBAR
Configura qualquer variável necessária para a macro "UNDERBAR". É usado para definir
"padoff_du", mas atualmente é um noop. No entanto, é altamente recomendável ainda
use-o para garantir compatibilidade com o passado e o futuro.

dUNDERBAR;

dXSARGS Configura ponteiros de pilha e marca para um XSUB, chamando dSP e dMARK. Configura o
variáveis ​​"ax" e "items" chamando "dAX" e "dITEMS". Isso geralmente é tratado
automaticamente por "xsubpp".

dXSARGS;

dXSI32 Configura a variável "ix" para um XSUB que possui apelidos. Isso geralmente é tratado
automaticamente por "xsubpp".

dXSI32;

items Variável configurada por "xsubpp" para indicar o número de itens na pilha.
Veja "Listas de parâmetros de comprimento variável" em perlxs.

I32 itens

ix Variável que é configurada por "xsubpp" para indicar qual dos aliases de um XSUB era
usado para invocá-lo. Veja "O ALIAS: Palavra-chave" em perlxs.

I32ix

RETVAL Variável que é configurada por "xsubpp" para conter o valor de retorno de um XSUB. Isto é
sempre o tipo adequado para o XSUB. Veja "A Variável RETVAL" em perlxs.

(qualquer que seja) RETVAL

ST Usado para acessar elementos na pilha do XSUB.

SV * ST (int ix)

ESTA Variável que é configurada por "xsubpp" para designar o objeto em um C ++ XSUB. Esse
é sempre o tipo apropriado para o objeto C ++. Consulte "CLASSE" e "Usando XS com C ++"
em perlxs.

(tanto faz) ISTO

BARRA INFERIOR
O SV * correspondente à variável $ _. Funciona mesmo se houver um $ _ léxico em
escopo.

Macro XS para declarar um XSUB e sua lista de parâmetros C. Isso é tratado por "xsubpp".
É o mesmo que usar a macro XS_EXTERNAL mais explícita.

XS_EXTERNAL
Macro para declarar um XSUB e sua lista de parâmetros C explicitamente exportando o
símbolos.

XS_INTERNO
Macro para declarar um XSUB e sua lista de parâmetros C sem exportar os símbolos.
Isso é tratado por "xsubpp" e geralmente preferível a exportar o XSUB
símbolos desnecessariamente.

Callback Funções

call_argv
Executa um retorno de chamada para a sub-rotina Perl nomeada e com escopo de pacote especificada com
"argv" (uma matriz de strings terminada em NULL) como argumentos. Veja perlcall.

Equivalente Perl aproximado: "& {" $ sub_name "} (@ $ argv)".

NOTA: a forma perl_ desta função está obsoleta.

I32 call_argv (const char * sub_name, sinalizadores I32,
char ** argv)

método_de_chamada
Executa um retorno de chamada para o método Perl especificado. O objeto abençoado deve estar em
a pilha. Veja perlcall.

NOTA: a forma perl_ desta função está obsoleta.

I32 call_method (const char * methname, sinalizadores I32)

call_pv Executa um retorno de chamada para o sub Perl especificado. Veja perlcall.

NOTA: a forma perl_ desta função está obsoleta.

I32 call_pv (const char * sub_name, sinalizadores I32)

call_sv Executa um retorno de chamada para o sub Perl especificado pelo SV.

Se nem o sinalizador "G_METHOD" ou "G_METHOD_NAMED" for fornecido, o SV pode ser qualquer
de um CV, um GV, uma referência a um CV, uma referência a um GV ou "SvPV (sv)" será usado
como o nome da sub-rotina a ser chamada.

Se o sinalizador "G_METHOD" for fornecido, o SV pode ser uma referência a um CV ou
"SvPV (sv)" será usado como o nome do método a ser chamado.

Se o sinalizador "G_METHOD_NAMED" for fornecido, "SvPV (sv)" será usado como o nome de
o método a ser chamado.

Alguns outros valores são tratados especialmente para uso interno e não devem ser
dependia.

Veja perlcall.

NOTA: a forma perl_ desta função está obsoleta.

I32 call_sv (SV * sv, sinalizadores VOL I32)

ENTER Abrindo colchete em um retorno de chamada. Veja "LEAVE" e perlcall.

DIGITAR;

eval_pv Diz ao Perl para "avaliar" a string dada no contexto escalar e retornar um resultado SV *.

NOTA: a forma perl_ desta função está obsoleta.

SV * eval_pv (const char * p, I32 croak_on_error)

eval_sv Diz ao Perl para "avaliar" a string no SV. Ele suporta os mesmos sinalizadores que
"call_sv", com a exceção óbvia de G_EVAL. Veja perlcall.

NOTA: a forma perl_ desta função está obsoleta.

I32 eval_sv (SV * sv, sinalizadores I32)

FREETMPS
Parêntese de fechamento para temporários em um retorno de chamada. Veja "SAVETMPS" e perlcall.

FREETMPS;

LEAVE Fechando colchete em um retorno de chamada. Veja "ENTER" e perlcall.

SAIR;

SALVARTMPS
Parêntese de abertura para temporários em um retorno de chamada. Veja "FREETMPS" e perlcall.

SALVARTMPS;

Personagem casas mudança

toFOLD Converte o caractere especificado em pasta. Se a entrada for qualquer coisa, menos um
Caractere ASCII maiúsculo, o próprio caractere de entrada é retornado. Variante
"toFOLD_A" é equivalente. (Não há equivalente "to_FOLD_L1" para o total
Intervalo Latin1, já que toda a generalidade de "toFOLD_uni" é necessária aqui.)

U8 toFOLD (U8 ch)

para FOLD_uni
Converte o ponto de código Unicode "cp" em sua versão de pasta e o armazena em
UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer apontou para
por "s" deve ter pelo menos "UTF8_MAXBYTES_CASE + 1" bytes desde a pasta
a versão pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão dobrada é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

UV toFOLD_uni (UV cp, U8 * s, STRLEN * lenp)

para FOLD_utf8
Converte o caractere codificado UTF-8 em "p" em sua versão de pasta e armazena
aquele em UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer
apontado por "s" deve ter pelo menos "UTF8_MAXBYTES_CASE + 1" bytes, já que o
a versão em pasta pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão dobrada é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

O caractere de entrada em "p" é considerado bem formado.

UV para FOLD_utf8 (U8 * p, U8 * s, STRLEN * lenp)

toLOWER Converte o caractere especificado em minúsculas. Se a entrada for qualquer coisa, menos um
Caractere ASCII maiúsculo, o próprio caractere de entrada é retornado. Variante
"toLOWER_A" é equivalente.

U8 toLOWER (U8 ch)

paraLOWER_L1
Converte o caractere Latin1 especificado em minúsculas. Os resultados são indefinidos
se a entrada não couber em um byte.

U8 aLOWER_L1 (U8 ch)

paraLOWER_LC
Converte o caractere especificado em minúsculas usando as regras de localidade atuais, se
possível; caso contrário, retorna o próprio caractere de entrada.

U8 aLOWER_LC (U8 ch)

paraLOWER_uni
Converte o ponto de código Unicode "cp" em sua versão em minúsculas e o armazena em
UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer apontou para
por "s" deve ser pelo menos "UTF8_MAXBYTES_CASE + 1" bytes desde a minúscula
a versão pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão em minúsculas é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

UV toLOWER_uni (UV cp, U8 * s, STRLEN * lenp)

paraLOWER_utf8
Converte o caractere codificado em UTF-8 em "p" em sua versão em minúsculas e armazena
aquele em UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer
apontado por "s" deve ter pelo menos "UTF8_MAXBYTES_CASE + 1" bytes, já que o
a versão em minúsculas pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão em minúsculas é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

O caractere de entrada em "p" é considerado bem formado.

UV toLOWER_utf8 (U8 * p, U8 * s, STRLEN * lenp)

toTITLE Converte o caractere especificado em titlecase. Se a entrada for qualquer coisa, menos um
Caractere ASCII minúsculo, o próprio caractere de entrada é retornado. Variante
"toTITLE_A" é equivalente. (Não há "toTITLE_L1" para todo o intervalo Latin1,
já que a generalidade completa de "toTITLE_uni" é necessária aqui. Titlecase não é um
conceito usado no tratamento de localidade, portanto, não há funcionalidade para isso.)

U8 toTITLE (U8 ch)

paraTITLE_uni
Converte o ponto de código Unicode "cp" em sua versão titlecase e o armazena em
UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer apontou para
por "s" deve ser pelo menos "UTF8_MAXBYTES_CASE + 1" bytes desde o titlecase
a versão pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão com caixa de título é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

UV toTITLE_uni (UV cp, U8 * s, STRLEN * lenp)

paraTITLE_utf8
Converte o caractere codificado UTF-8 em "p" em sua versão titlecase e armazena
aquele em UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer
apontado por "s" deve ter pelo menos "UTF8_MAXBYTES_CASE + 1" bytes, já que o
A versão do titlecase pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão com caixa de título é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

O caractere de entrada em "p" é considerado bem formado.

UV toTITLE_utf8 (U8 * p, U8 * s, STRLEN * lenp)

toUPPER Converte o caractere especificado em maiúsculas. Se a entrada for qualquer coisa, menos um
Caractere ASCII minúsculo, o próprio caractere de entrada é retornado. Variante
"toUPPER_A" é equivalente.

U8 para SUPER (U8 ch)

para UPPER_uni
Converte o ponto de código Unicode "cp" em sua versão em maiúsculas e o armazena em
UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer apontou para
por "s" deve ser pelo menos "UTF8_MAXBYTES_CASE + 1" bytes desde a maiúscula
a versão pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão em maiúsculas é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

UV toUPPER_uni (UV cp, U8 * s, STRLEN * lenp)

para UPPER_utf8
Converte o caractere codificado UTF-8 em "p" em sua versão maiúscula e armazena
aquele em UTF-8 em "s" e seu comprimento em bytes em "lenp". Observe que o buffer
apontado por "s" deve ter pelo menos "UTF8_MAXBYTES_CASE + 1" bytes, já que o
a versão em maiúsculas pode ser mais longa do que o caractere original.

O primeiro ponto de código da versão em maiúsculas é retornado (mas observe, como explicado
logo acima, para que possa haver mais.)

O caractere de entrada em "p" é considerado bem formado.

UV toUPPER_utf8 (U8 * p, U8 * s, STRLEN * lenp)

Personagem classificação

Esta seção é sobre funções (na verdade, macros) que classificam os caracteres em tipos, como
como pontuação versus alfabética, etc. A maioria destes são análogos à expressão regular
classes de personagens. (Veja "Classes de caracteres POSIX" em perlrecharclass.) Existem vários
variantes para cada classe. (Nem todas as macros têm todas as variantes; cada item abaixo lista o
aqueles válidos para ele.) Nenhum é afetado por "bytes de uso", e apenas aqueles com "LC" no
nome são afetados pela localidade atual.

A função de base, por exemplo, "isALPHA ()", leva um octeto (um "char" ou um "U8") como entrada
e retorna um booleano indicando se o caractere representado por esse octeto é ou não (ou
em plataformas não ASCII, corresponde a) um caractere ASCII na classe nomeada com base em
plataforma, regras Unicode e Perl. Se a entrada for um número que não cabe em um octeto,
FALSE é retornado.

A variante "isFOO_A" (por exemplo, "isALPHA_A ()") é idêntica à função de base sem sufixo
"_UMA".

A variante "isFOO_L1" impõe o caractere Latin-1 (ou equivalente EBCDIC) definido para o
plataforma. Ou seja, os pontos de código que são ASCII não são afetados, uma vez que ASCII é um subconjunto
de Latim-1. Mas os pontos de código não ASCII são tratados como se fossem caracteres Latin-1.
Por exemplo, "isWORDCHAR_L1 ()" retornará verdadeiro quando chamado com o ponto de código 0xDF,
que é um caractere de palavra em ASCII e EBCDIC (embora represente diferentes
personagens em cada um).

A variante "isFOO_uni" é como a variante "isFOO_L1", mas aceita qualquer ponto de código UV como
entrada. Se o ponto de código for maior que 255, as regras Unicode são usadas para determinar se ele é
na classe de personagem. Por exemplo, "éWORDCHAR_uni(0x100) "retorna TRUE, uma vez que 0x100 é
LETRA A MAIÚSCULA LATINA COM MACRON em Unicode, e é um caractere de palavra.

A variante "isFOO_utf8" é como "isFOO_uni", mas a entrada é um ponteiro para um (conhecido por ser
bem formada) string codificada em UTF-8 ("U8 *" ou "char *"). A classificação de apenas o
o primeiro caractere (possivelmente multibyte) na string é testado.

A variante "isFOO_LC" é como as variantes "isFOO_A" e "isFOO_L1", mas o resultado é baseado
no local atual, que é o significado de "LC" no nome. Se Perl pode determinar
se a localidade atual é uma localidade UTF-8, ele usa as regras Unicode publicadas; de outra forma,
ele usa a função de biblioteca C que fornece a classificação nomeada. Por exemplo,
"isDIGIT_LC ()" quando não está em um locale UTF-8 retorna o resultado da chamada de "isdigit ()".
FALSE é sempre retornado se a entrada não couber em um octeto. Em algumas plataformas onde
a função da biblioteca C é conhecida por ser defeituosa, Perl muda seu resultado para seguir o
Regras do padrão POSIX.

A variante "isFOO_LC_uvchr" é como "isFOO_LC", mas é definida em qualquer UV. Retorna o
o mesmo que "isFOO_LC" para pontos de código de entrada menores que 256, e retorna o código permanente, não
afetado por localidade, resultados Unicode para os maiores.

A variante "isFOO_LC_utf8" é como "isFOO_LC_uvchr", mas a entrada é um ponteiro para um (conhecido
para ser bem formada) string codificada em UTF-8 ("U8 *" ou "char *"). A classificação de apenas
o primeiro caractere (possivelmente multibyte) na string é testado.

isALPHA Retorna um booleano indicando se o caractere especificado é alfabético
caractere, análogo a "m / [[: alfa:]] /". Veja o topo desta seção para um
explicação das variantes "isALPHA_A", "isALPHA_L1", "isALPHA_uni", "isALPHA_utf8",
"isALPHA_LC", "isALPHA_LC_uvchr" e "isALPHA_LC_utf8".

bool isALPHA (char ch)

isALFANUMÉRICO
Retorna um booleano indicando se o caractere especificado é um
caractere alfabético ou dígito decimal, análogo a "m / [[: alnum:]] /". Veja o topo
desta seção para uma explicação das variantes "isALPHANUMERIC_A",
"isALPHANUMERIC_L1", "isALPHANUMERIC_uni", "isALPHANUMERIC_utf8",
"isALPHANUMERIC_LC", "isALPHANUMERIC_LC_uvchr" e "isALPHANUMERIC_LC_utf8".

bool isALPHANUMERIC (char ch)

isASCII Retorna um booleano indicando se o caractere especificado é um dos 128
caracteres no conjunto de caracteres ASCII, análogo a "m / [[: ascii:]] /". Em não-
Plataformas ASCII, ele retorna VERDADEIRO se este caractere corresponder a um ASCII
personagem. Variantes "isASCII_A ()" e "isASCII_L1 ()" são idênticas a
"isASCII ()". Consulte o topo desta seção para obter uma explicação das variantes
"isASCII_uni", "isASCII_utf8", "isASCII_LC", "isASCII_LC_uvchr" e
"isASCII_LC_utf8". Observe, no entanto, que algumas plataformas não possuem a biblioteca C
rotina "isascii ()". Nestes casos, as variantes cujos nomes contêm "LC" são
o mesmo que os correspondentes sem.

Observe também que, como todos os caracteres ASCII são invariantes UTF-8 (o que significa que eles
têm exatamente a mesma representação (sempre um único byte) se codificado em UTF-8
ou não), "isASCII" dará os resultados corretos quando chamado com qualquer byte em qualquer
string codificada ou não em UTF-8. E da mesma forma "isASCII_utf8" funcionará corretamente
em qualquer string codificado ou não em UTF-8.

bool isASCII (char ch)

isBLANK Retorna um booleano indicando se o caractere especificado é um caractere
considerado um espaço em branco, análogo a "m / [[: espaço em branco:]] /". Veja o topo desta
seção para uma explicação das variantes "isBLANK_A", "isBLANK_L1", "isBLANK_uni",
"isBLANK_utf8", "isBLANK_LC", "isBLANK_LC_uvchr" e "isBLANK_LC_utf8". Observação,
no entanto, algumas plataformas não possuem a rotina de biblioteca C "isblank ()". No
nestes casos, as variantes cujos nomes contêm "LC" são as mesmas que o
correspondentes sem.

bool isBLANK (char ch)

isCNTRL Retorna um booleano indicando se o caractere especificado é um controle
caractere, análogo a "m / [[: cntrl:]] /". Veja o topo desta seção para um
explicação das variantes "isCNTRL_A", "isCNTRL_L1", "isCNTRL_uni", "isCNTRL_utf8",
"isCNTRL_LC", "isCNTRL_LC_uvchr" e "isCNTRL_LC_utf8" Em plataformas EBCDIC, você
quase sempre deseja usar a variante "isCNTRL_L1".

bool isCNTRL (char ch)

isDIGIT Retorna um booleano indicando se o caractere especificado é um dígito, análogo
para "m / [[: dígito:]] /". Variantes "isDIGIT_A" e "isDIGIT_L1" são idênticas a
"isDIGIT". Consulte o topo desta seção para obter uma explicação das variantes
"isDIGIT_uni", "isDIGIT_utf8", "isDIGIT_LC", "isDIGIT_LC_uvchr" e
"isDIGIT_LC_utf8".

bool isDIGIT (char ch)

isGRAPH Retorna um booleano indicando se o caractere especificado é um gráfico
caractere, análogo a "m / [[: gráfico:]] /". Veja o topo desta seção para um
explicação das variantes "isGRAPH_A", "isGRAPH_L1", "isGRAPH_uni", "isGRAPH_utf8",
"isGRAPH_LC", "isGRAPH_LC_uvchr" e "isGRAPH_LC_utf8".

bool isGRAPH (char ch)

éIDCONT
Retorna um booleano indicando se o caractere especificado pode ser o segundo ou
caractere subsequente de um identificador. Isso é muito próximo, mas não exatamente do
mesmo que a propriedade Unicode oficial "XID_Continue". A diferença é que este
retorna verdadeiro apenas se o caractere de entrada também corresponder a "isWORDCHAR". Veja o topo
desta seção para uma explicação das variantes "isIDCONT_A", "isIDCONT_L1",
"isIDCONT_uni", "isIDCONT_utf8", "isIDCONT_LC", "isIDCONT_LC_uvchr" e
"isIDCONT_LC_utf8".

bool isIDCONT (char ch)

éIDFIRST
Retorna um booleano indicando se o caractere especificado pode ser o primeiro
caráter de um identificador. Isso é muito próximo, mas não exatamente igual ao
propriedade Unicode oficial "XID_Start". A diferença é que isso retorna verdadeiro
somente se o caractere de entrada também corresponder a "isWORDCHAR". Veja o topo desta
seção para uma explicação das variantes "isIDFIRST_A", "isIDFIRST_L1",
"isIDFIRST_uni", "isIDFIRST_utf8", "isIDFIRST_LC", "isIDFIRST_LC_uvchr" e
"isIDFIRST_LC_utf8".

bool isIDFIRST (char ch)

isLOWER Retorna um booleano indicando se o caractere especificado está em minúsculas
caractere, análogo a "m / [[: inferior:]] /". Veja o topo desta seção para um
explicação das variantes "isLOWER_A", "isLOWER_L1", "isLOWER_uni", "isLOWER_utf8",
"isLOWER_LC", "isLOWER_LC_uvchr" e "isLOWER_LC_utf8".

bool isLOWER (char ch)

isOCTAL Retorna um booleano indicando se o caractere especificado é um dígito octal,
[0-7]. As únicas duas variantes são "isOCTAL_A" e "isOCTAL_L1"; cada um é idêntico
para "isOCTAL".

bool isOCTAL (char ch)

isPRINT Retorna um booleano indicando se o caractere especificado é imprimível
caractere, análogo a "m / [[: imprimir:]] /". Veja o topo desta seção para um
explicação das variantes "isPRINT_A", "isPRINT_L1", "isPRINT_uni", "isPRINT_utf8",
"isPRINT_LC", "isPRINT_LC_uvchr" e "isPRINT_LC_utf8".

bool isPRINT (char ch)

isPSXSPC
(abreviação de Posix Space) A partir de 5.18, é idêntico em todas as suas formas a
as macros "isSPACE ()" correspondentes. As formas de local desta macro são
idênticos aos seus formulários "isSPACE ()" correspondentes em todas as versões do Perl. No
versões anteriores à 5.18, os formulários não-local diferem de seus formulários "isSPACE ()"
apenas em que os formulários "isSPACE ()" não correspondem a uma guia vertical, e o
Os formulários "isPSXSPC ()" sim. Caso contrário, eles são idênticos. Portanto, esta macro é
análogo ao que "m / [[: espaço:]] /" corresponde em uma expressão regular. Veja o topo
desta seção para uma explicação das variantes "isPSXSPC_A", "isPSXSPC_L1",
"isPSXSPC_uni", "isPSXSPC_utf8", "isPSXSPC_LC", "isPSXSPC_LC_uvchr" e
"isPSXSPC_LC_utf8".

bool isPSXSPC (char ch)

isPUNCT Retorna um booleano indicando se o caractere especificado é uma pontuação
caractere, análogo a "m / [[: ponto:]] /". Observe que a definição do que é
a pontuação não é tão direta quanto se poderia desejar. Veja "Personagem POSIX
Classes "em perlrecharclass para detalhes. Veja o topo desta seção para uma
explicação das variantes "isPUNCT_A", "isPUNCT_L1", "isPUNCT_uni", "isPUNCT_utf8",
"isPUNCT_LC", "isPUNCT_LC_uvchr" e "isPUNCT_LC_utf8".

bool isPUNCT (char ch)

isSPACE Retorna um booleano indicando se o caractere especificado é um espaço em branco
personagem. Isso é análogo ao que "m / \ s /" corresponde em uma expressão regular.
A partir do Perl 5.18, isso também corresponde ao que "m / [[: space:]] /" faz. Antes de
5.18, apenas as formas de local desta macro (aquelas com "LC" em seus nomes)
correspondeu precisamente ao que "m / [[: space:]] /" faz. Nesses lançamentos, o único
diferença, nas variantes não locais, era que "isSPACE ()" não correspondia a um
guia vertical. (Consulte "isPSXSPC" para uma macro que corresponde a uma guia vertical em todos
versões.) Consulte o topo desta seção para obter uma explicação das variantes.
"isSPACE_A", "isSPACE_L1", "isSPACE_uni", "isSPACE_utf8", "isSPACE_LC",
"isSPACE_LC_uvchr" e "isSPACE_LC_utf8".

bool isSPACE (char ch)

isUPPER Retorna um booleano indicando se o caractere especificado é maiúsculo
caractere, análogo a "m / [[: superior:]] /". Veja o topo desta seção para um
explicação das variantes "isUPPER_A", "isUPPER_L1", "isUPPER_uni", "isUPPER_utf8",
"isUPPER_LC", "isUPPER_LC_uvchr" e "isUPPER_LC_utf8".

bool isUPPER (char ch)

éWORDCHAR
Retorna um booleano indicando se o caractere especificado é um caractere que
é um caractere de palavra, análogo ao que "m / \ w /" e "m / [[: palavra:]] /" correspondem em um
expressão regular. Um caractere de palavra é um caractere alfabético, um dígito decimal,
um caractere de pontuação de conexão (como um sublinhado) ou um caractere de "marca"
que atribui a um desses (como algum tipo de sotaque). "isALNUM ()" é um
sinônimo fornecido para compatibilidade com versões anteriores, embora um caractere de palavra inclua
mais do que o significado padrão da linguagem C de alfanumérico. Veja o topo desta
seção para uma explicação das variantes "isWORDCHAR_A", "isWORDCHAR_L1",
"isWORDCHAR_uni" e "isWORDCHAR_utf8". "isWORDCHAR_LC", "isWORDCHAR_LC_uvchr",
e "isWORDCHAR_LC_utf8" também são descritos lá, mas incluem adicionalmente o
sublinhado nativo da plataforma.

bool isWORDCHAR (char ch)

éXDÍGITO
Retorna um booleano indicando se o caractere especificado é um hexadecimal
dígito. Na faixa ASCII, são "[0-9A-Fa-f]". Variantes "isXDIGIT_A ()" e
"isXDIGIT_L1 ()" são idênticos a "isXDIGIT ()". Veja o topo desta seção para um
explicação das variantes "isXDIGIT_uni", "isXDIGIT_utf8", "isXDIGIT_LC",
"isXDIGIT_LC_uvchr" e "isXDIGIT_LC_utf8".

bool isXDIGIT (char ch)

Clonagem an intérprete

perl_clone
Crie e retorne um novo intérprete clonando o atual.

perl_clone usa estes sinalizadores como parâmetros:

CLONEf_COPY_STACKS - é usado para, bem, copiar as pilhas também, sem ele nós apenas
clonar os dados e zerar as pilhas, com isso copiamos as pilhas e o novo perl
o intérprete está pronto para funcionar exatamente no mesmo ponto que o anterior. o
o código do pseudo-fork usa COPY_STACKS enquanto o thread-> create não usa.

CLONEf_KEEP_PTR_TABLE - perl_clone mantém uma ptr_table com o ponteiro do antigo
variável como uma chave e a nova variável como um valor, o que permite verificar se
algo foi clonado e não clone novamente, mas apenas use o valor e
aumentar o refcount. Se KEEP_PTR_TABLE não for definido, então perl_clone irá matar o
ptr_table usando a função "ptr_table_free (PL_ptr_table); PL_ptr_table = NULL;",
razão para mantê-lo por perto é se você quiser enganar algumas de suas próprias variáveis ​​que são
fora do gráfico perl scans, um exemplo deste código está em threads.xs create.

CLONEf_CLONE_HOST - Isso é uma coisa do win32, é ignorado no unix, diz ao perls
código win32host (que é c ++) para clonar a si mesmo, isso é necessário no win32 se você quiser
para executar dois threads ao mesmo tempo, se você quiser apenas fazer algumas coisas em um
separe o intérprete de perl e, em seguida, jogue-o fora e volte ao original,
você não precisa fazer nada.

PerlInterpreter * perl_clone (
PerlInterpreter * proto_perl,
Bandeiras UV
)

Tempo de compilação escopo ganchos

BhkDESATIVAR
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Desative temporariamente uma entrada nesta estrutura BHK, limpando o apropriado
bandeira. qual é um token de pré-processador que indica qual entrada desativar.

void BhkDISABLE (BHK * hk, que)

BhkENABLE
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Reative uma entrada nesta estrutura BHK, definindo o sinalizador apropriado. qual
é um token de pré-processador que indica qual entrada habilitar. Isso irá afirmar (sob
-DDEBUGGING) se a entrada não contiver um ponteiro válido.

void BhkENABLE (BHK * hk, que)

BhkENTRY_set
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Defina uma entrada na estrutura BHK e defina os sinalizadores para indicar que é válido.
qual é um token de pré-processamento que indica qual entrada definir. O tipo de ptr
depende da entrada.

void BhkENTRY_set (BHK * hk, que, void * ptr)

blockhook_register
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Registre um conjunto de ganchos a serem chamados quando o escopo léxico Perl mudar em
tempo de compilação. Veja "ganchos de escopo de tempo de compilação" em perlguts.

NOTA: esta função deve ser explicitamente chamada como Perl_blockhook_register com um
parâmetro aTHX_.

void Perl_blockhook_register (pTHX_ BHK * hk)

COP Insinuar Hashes

cophh_2hv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Gera e retorna um hash Perl padrão que representa o conjunto completo de chave / valor
pares no policial insinua hash coph. bandeiras não é usado no momento e deve ser zero.

HV * cophh_2hv (const COPHH * cophh, sinalizadores U32)

cophh_copy
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Faça e devolva uma cópia completa do hash de dicas do policial coph.

COPHH * cophh_copy (COPHH * cophh)

cophh_delete_pv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_delete_pvn", mas leva uma string terminada em nulo em vez de um
par string / comprimento.

COPHH * cophh_delete_pv (const COPHH * cophh,
chave const char *, hash U32,
Sinalizadores U32)

cophh_delete_pvn
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Exclua uma chave e seu valor associado do hash de dicas do policial coph, e retorna
o hash modificado. O ponteiro de hash retornado em geral não é o mesmo que o
ponteiro de hash que foi passado. O hash de entrada é consumido pela função, e
o ponteiro para ele não deve ser usado posteriormente. Use "cophh_copy" se precisar
ambos os hashes.

A chave é especificada por chavepv e Keylen. Se bandeiras tem o bit "COPHH_KEY_UTF8"
definido, os principais octetos são interpretados como UTF-8, caso contrário, eles são interpretados como
Latina-1. hash é um hash pré-computado da string da chave, ou zero se não foi
pré-computado.

COPHH * cophh_delete_pvn (COPHH * cophh,
const char * keypv,
Tecla STRLEN, hash U32,
Sinalizadores U32)

cophh_delete_pvs
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_delete_pvn", mas leva uma string literal em vez de uma string / comprimento
par e nenhum hash pré-computado.

COPHH * cophh_delete_pvs (const COPHH * cophh,
const char * key, U32 flags)

cophh_delete_sv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_delete_pvn", mas leva um escalar Perl em vez de um par string / comprimento.

COPHH * cophh_delete_sv (const COPHH * cophh, chave SV *,
Hash U32, sinalizadores U32)

cophh_fetch_pv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_fetch_pvn", mas leva uma string terminada em nulo em vez de um
par string / comprimento.

SV * cophh_fetch_pv (const COPHH * cophh,
chave const char *, hash U32,
Sinalizadores U32)

cophh_fetch_pvn
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Procure a entrada no hash de dicas do policial coph com a chave especificada por chavepv e
Keylen. Se bandeiras tem o bit "COPHH_KEY_UTF8" definido, os octetos principais são interpretados
como UTF-8, caso contrário, são interpretados como Latin-1. hash é um hash pré-computado
da string da chave ou zero se não tiver sido pré-computado. Retorna um mortal
cópia escalar do valor associado à chave, ou & PL_sv_placeholder se houver
não há valor associado à chave.

SV * cophh_fetch_pvn (const COPHH * cophh,
const char * keypv,
Tecla STRLEN, hash U32,
Sinalizadores U32)

cophh_fetch_pvs
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_fetch_pvn", mas leva uma string literal em vez de uma string / comprimento
par e nenhum hash pré-computado.

SV * cophh_fetch_pvs (const COPHH * cophh,
const char * key, U32 flags)

cophh_fetch_sv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_fetch_pvn", mas leva um escalar Perl em vez de um par string / comprimento.

SV * cophh_fetch_sv (const COPHH * cophh, chave SV *,
Hash U32, sinalizadores U32)

cophh_free
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Descarte o hash de dicas de policial coph, liberando todos os recursos associados a ele.

void cophh_free (COPHH * cophh)

cophh_new_empty
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Gere e retorne um novo hash de dicas de policiais sem entradas.

COPHH * cophh_new_empty ()

cophh_store_pv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_store_pvn", mas leva uma string terminada em nulo em vez de um
par string / comprimento.

COPHH * cophh_store_pv (const COPHH * cophh,
chave const char *, hash U32,
Valor SV *, sinalizadores U32)

cophh_store_pvn
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Armazena um valor, associado a uma chave, no hash de dicas de policial coph, e retorna
o hash modificado. O ponteiro de hash retornado em geral não é o mesmo que o
ponteiro de hash que foi passado. O hash de entrada é consumido pela função, e
o ponteiro para ele não deve ser usado posteriormente. Use "cophh_copy" se precisar
ambos os hashes.

A chave é especificada por chavepv e Keylen. Se bandeiras tem o bit "COPHH_KEY_UTF8"
definido, os principais octetos são interpretados como UTF-8, caso contrário, eles são interpretados como
Latina-1. hash é um hash pré-computado da string da chave, ou zero se não foi
pré-computado.

valor é o valor escalar a ser armazenado para esta chave. valor é copiado por este
função, que assim não se aproprie de qualquer referência a ela, e posteriormente
mudanças no escalar não serão refletidas no valor visível nas dicas do policial
cerquilha. Tipos complexos de escalares não serão armazenados com integridade referencial, mas
será coagido a strings.

COPHH * cophh_store_pvn (COPHH * cophh, const char * keypv,
Tecla STRLEN, hash U32,
Valor SV *, sinalizadores U32)

cophh_store_pvs
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_store_pvn", mas leva uma string literal em vez de uma string / comprimento
par e nenhum hash pré-computado.

COPHH * cophh_store_pvs (const COPHH * cophh,
chave const char *, valor SV *,
Sinalizadores U32)

cophh_store_sv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "cophh_store_pvn", mas leva um escalar Perl em vez de um par string / comprimento.

COPHH * cophh_store_sv (const COPHH * cophh, chave SV *,
Hash U32, valor SV *, sinalizadores U32)

COP Insinuar Leitura

cop_hints_2hv
Gera e retorna um hash Perl padrão que representa o conjunto completo de dicas
entradas no policial policial. bandeiras não é usado no momento e deve ser zero.

HV * cop_hints_2hv (const COP * cop, sinalizadores U32)

cop_hints_fetch_pv
Como "cop_hints_fetch_pvn", mas leva uma string terminada em nulo em vez de um
par string / comprimento.

SV * cop_hints_fetch_pv (const COP * cop,
chave const char *, hash U32,
Sinalizadores U32)

cop_hints_fetch_pvn
Procure a entrada da dica no policial policial com a chave especificada por chavepv e Keylen.
If bandeiras tem o bit "COPHH_KEY_UTF8" definido, os principais octetos são interpretados como
UTF-8, caso contrário, eles são interpretados como Latin-1. hash é um hash pré-computado de
a string da chave ou zero se não tiver sido pré-computada. Retorna um escalar mortal
cópia do valor associado à chave, ou & PL_sv_placeholder se não houver
valor associado à chave.

SV * cop_hints_fetch_pvn (const COP * cop,
const char * keypv,
Tecla STRLEN, hash U32,
Sinalizadores U32)

cop_hints_fetch_pvs
Como "cop_hints_fetch_pvn", mas leva uma string literal em vez de uma string / comprimento
par e nenhum hash pré-computado.

SV * cop_hints_fetch_pvs (const COP * cop,
const char * key, U32 flags)

cop_hints_fetch_sv
Como "cop_hints_fetch_pvn", mas leva um escalar Perl em vez de uma string / comprimento
par.

SV * cop_hints_fetch_sv (const COP * cop, chave SV *,
Hash U32, sinalizadores U32)

Personalizadas Operadores

custom_op_register
Registre uma operação personalizada. Consulte "Operadores personalizados" em perlguts.

NOTA: esta função deve ser explicitamente chamada como Perl_custom_op_register com um
parâmetro aTHX_.

void Perl_custom_op_register (pTHX_
Perl_ppaddr_t ppaddr,
const XOP * xop)

custom_op_xop
Retorne a estrutura XOP para uma determinada operação personalizada. Esta macro deve ser considerada
interno para OP_NAME e as outras macros de acesso: use-as em seu lugar. Esta macro
chama uma função. Antes de 5.19.6, isso era implementado como uma função.

NOTA: esta função deve ser explicitamente chamada como Perl_custom_op_xop com um aTHX_
parâmetro.

const XOP * Perl_custom_op_xop (pTHX_ const OP * o)

Xop DESATIVAR
Desative temporariamente um membro do XOP, limpando o sinalizador apropriado.

void XopDISABLE (XOP * xop, que)

XopHABILITAR
Reative um membro do XOP que foi desativado.

void XopENABLE (XOP * xop, que)

XopENTRY
Retorne um membro da estrutura XOP. qual é um token cpp que indica qual entrada
para retornar. Se o membro não for definido, isso retornará um valor padrão. O retorno
tipo depende de qual. Esta macro avalia seus argumentos mais de uma vez. Se você
estão usando "Perl_custom_op_xop" para recuperar um "XOP *" de um "OP *", use mais
eficiente "XopENTRYCUSTOM" em vez disso.

XopENTRY (XOP * xop, que)

XopENTRYCUSTOM
Exatamente como "XopENTRY (XopENTRY (Perl_custom_op_xop (aTHX_ o), que)", mas mais
eficiente. o qual parâmetro é idêntico a "XopENTRY".

XopENTRYCUSTOM (const OP * o, que)

XopENTRY_set
Defina um membro da estrutura XOP. qual é um token cpp que indica qual entrada para
definir. Veja "Operadores personalizados" em perlguts para detalhes sobre os membros disponíveis
e como eles são usados. Esta macro avalia seu argumento mais de uma vez.

void XopENTRY_set (XOP * xop, que, valor)

XopFLAGS
Retorne os sinalizadores do XOP.

U32 XopFLAGS (XOP * xop)

CV Manipulação Funções

Esta seção documenta funções para manipular CVs que são valores de código ou sub-rotinas.
Para obter mais informações, consulte perlguts.

chamador_cx
O equivalente do gravador XSUB de chamador (). A estrutura "PERL_CONTEXT" retornada
pode ser interrogado para encontrar todas as informações retornadas ao Perl pelo "chamador".
Observe que os XSUBs não obtêm um frame de pilha, então "caller_cx (0, NULL)" retornará
informações para o código Perl imediatamente circundante.

Esta função ignora as chamadas automáticas para & DB :: sub feitas em nome do
depurador. Se o frame da pilha solicitado foi um sub chamado por "DB :: sub", o retorno
valor será o frame para a chamada a "DB :: sub", desde que tenha a linha correta
número / etc. para o site da chamada. Se dbcxp não for "NULL", será definido como um
ponteiro para o quadro da sub-chamada em si.

const PERL_CONTEXT * caller_cx (
Nível I32,
const PERL_CONTEXT ** dbcxp
)

CvSTASH Retorna o estoque do CV. Um stash é o hash da tabela de símbolos, contendo o
variáveis ​​com escopo de pacote no pacote onde a sub-rotina foi definida. Para
mais informações, veja perlguts.

Isso também tem um uso especial com subs XS AUTOLOAD. Consulte "Carregamento automático com XSUBs"
em perlguts.

HV * CvSTASH (CV * cv)

encontrar_runcv
Localize o CV correspondente à sub ou avaliação em execução no momento. Se db_seqp for
non_null, pule os CVs que estão no pacote DB e preencha * db_seqp com o policial
número de sequência no ponto em que o código DB :: foi inserido. (Isso permite
depuradores para avaliar no escopo do ponto de interrupção, em vez de no escopo do
próprio depurador.)

CV * find_runcv (U32 * db_seqp)

get_cv Usa "strlen" para obter o comprimento de "name" e, a seguir, chama "get_cvn_flags".

NOTA: a forma perl_ desta função está obsoleta.

CV * get_cv (const char * name, I32 flags)

get_cvn_flags
Retorna o CV da sub-rotina Perl especificada. "sinalizadores" são passados ​​para
"gv_fetchpvn_flags". Se "GV_ADD" estiver definido e a sub-rotina Perl não existir
então ele será declarado (o que tem o mesmo efeito que dizer "subnome;"). Se
"GV_ADD" não está definido e a sub-rotina não existe, então NULL é retornado.

NOTA: a forma perl_ desta função está obsoleta.

CV * get_cvn_flags (const char * name, STRLEN len,
bandeiras I32)

depuração Utilities

despejar_tudo
Despeja todo o optree do programa atual, começando em "PL_main_root" para
"STDERR". Também despeja as opções para todas as sub-rotinas visíveis em "PL_defstash".

void dump_all ()

dump_packsubs
Despeja as opções para todas as sub-rotinas visíveis em "stash".

void dump_packsubs (const HV * stash)

op_dump Despeja o optree começando em OP "o" para "STDERR".

void op_dump (const OP * o)

sv_dump Despeja o conteúdo de um SV para o gerenciador de arquivos "STDERR".

Para obter um exemplo de sua saída, consulte Devel :: Peek.

void sv_dump (SV * sv)

Ecrã e lixeira funções

exibição_pv
Semelhante a

pv_escape (dsv, pv, cur, pvlim, PERL_PV_ESCAPE_QUOTE);

exceto que um "\ 0" adicional será anexado à string quando len> cur e
pv [cur] é "\ 0".

Observe que a string final pode ter até 7 caracteres a mais do que pvlim.

char * pv_display (SV * dsv, const char * pv, STRLEN cur,
STRLEN len, STRLEN pvlim)

pv_escape
Escapa no máximo os primeiros caracteres de "contagem" de pv e coloca os resultados em dsv como
que o tamanho da string de escape não excederá "max" chars e não
conter quaisquer sequências de escape incompletas. O número de bytes escapados será
retornado no parâmetro de escape STRLEN * se não for nulo. Quando o dsv
parâmetro é nulo nenhum escape realmente ocorre, mas o número de bytes que seriam
ser escapado se não for nulo será calculado.

Se os sinalizadores contiverem PERL_PV_ESCAPE_QUOTE, quaisquer aspas duplas na string
também ser escapado.

Normalmente, o SV será limpo antes que a string escapada seja preparada, mas quando
PERL_PV_ESCAPE_NOCLEAR está definido, isso não ocorrerá.

Se PERL_PV_ESCAPE_UNI for definido, a string de entrada é tratada como UTF-8 se
PERL_PV_ESCAPE_UNI_DETECT é definido, então a string de entrada é digitalizada usando
"is_utf8_string ()" para determinar se é UTF-8.

Se PERL_PV_ESCAPE_ALL for definido, todos os caracteres de entrada serão impressos usando "\ x01F1"
escapes de estilo, caso contrário, se PERL_PV_ESCAPE_NONASCII estiver definido, apenas caracteres não ASCII
será escapado usando este estilo; caso contrário, apenas caracteres acima de 255 serão assim
escapou; outros caracteres não imprimíveis usarão padrões octais ou comuns de escape, como
"\ n". Caso contrário, se PERL_PV_ESCAPE_NOBACKSLASH, todos os caracteres abaixo de 255 serão
tratados como imprimíveis e serão impressos como literais.

Se PERL_PV_ESCAPE_FIRSTCHAR for definido, apenas o primeiro caractere da string será
com escape, independentemente do máx. Se a saída for em hexadecimal, será
retornado como uma sequência hexadecimal simples. Assim, a saída será um único caractere,
uma sequência de escape octal, um escape especial como "\ n" ou um valor hexadecimal.

Se PERL_PV_ESCAPE_RE for definido, o caractere de escape usado será um '%' e não um
'\\'. Isso ocorre porque regexes muitas vezes contêm sequências com barra invertida, enquanto
'%' não é um caractere particularmente comum em padrões.

Retorna um ponteiro para o texto de escape mantido por dsv.

char * pv_escape (SV * dsv, char const * const str,
contagem de STRLEN const, max STRLEN constante,
STRLEN * const escapou,
sinalizadores const U32)

pv_pretty
Converte uma string em algo apresentável, manipulando o escape via pv_escape ()
e apoiando citações e elipses.

Se o sinalizador PERL_PV_PRETTY_QUOTE for definido, o resultado terá aspas duplas com
quaisquer aspas duplas na string escaparam. Caso contrário, se o PERL_PV_PRETTY_LTGT
sinalizador é definido e o resultado é colocado entre colchetes angulares.

Se o sinalizador PERL_PV_PRETTY_ELLIPSES estiver definido e nem todos os caracteres na string forem
a saída, então, reticências "..." serão anexadas à string. Observe que este
acontece APÓS ter sido citado.

Se start_color não for nulo, então ele será inserido após a aspa de abertura (se
há um), mas antes do texto com escape. Se end_color não for nulo, então
ser inserido após o texto com escape, mas antes de quaisquer aspas ou reticências.

Retorna um ponteiro para o texto aprimorado mantido por dsv.

char * pv_pretty (SV * dsv, char const * const str,
contagem de STRLEN const, max STRLEN constante,
char const * const cor_inicial,
char const * const end_color,
sinalizadores const U32)

Incorporação Funções

cv_clone
Clone um CV, fazendo um fechamento lexical. proto fornece o protótipo do
função: seu código, estrutura do teclado e outros atributos. O protótipo é
combinado com uma captura de léxicos externos aos quais o código se refere, que são
retirado da instância atualmente em execução do código imediatamente circundante.

CV * cv_clone (CV * proto)

cv_name Retorna um SV contendo o nome do CV, principalmente para uso em relatórios de erros.
O CV pode, na verdade, ser um GV, caso em que o SV retornado contém os GVs
nome. Qualquer coisa que não seja um GV ou CV é tratada como uma corda já segurando o
nome do sub, mas isso pode mudar no futuro.

Um SV pode ser passado como um segundo argumento. Nesse caso, o nome será atribuído a ele
e será devolvido. Caso contrário, o SV retornado será um novo mortal.

Se o bandeiras incluir CV_NAME_NOTQUAL, então o nome do pacote não será incluído.
Se o primeiro argumento não for um CV nem um GV, este sinalizador será ignorado (sujeito a
mudança).

SV * cv_name (CV * cv, SV * sv, sinalizadores U32)

cv_undef
Limpe todos os componentes ativos de um currículo. Isso pode acontecer por um
explícito "undef & foo", ou pela contagem de referência indo para zero. Na antiga
caso, mantemos o ponteiro CvOUTSIDE, para que qualquer filho anônimo ainda possa
siga a cadeia de escopo lexical completa.

void cv_undef (CV * cv)

find_rundefsv
Encontre e retorne a variável chamada $ _ no escopo léxico do
função atualmente em execução. Este pode ser um léxico $ _ ou, de outra forma, será o
global.

SV * find_rundefsv ()

find_rundefsvoffset
DESCONTINUADA! É planejado remover esta função de uma versão futura do Perl.
Não o use para novo código; remova-o do código existente.

Encontre a posição do léxico $ _ no bloco do atualmente em execução
função. Retorna o deslocamento no pad atual, ou "NOT_IN_PAD" se não houver
léxico $ _ no escopo (neste caso, o global deve ser usado).
"find_rundefsv" é provavelmente mais conveniente.

NOTA: a forma perl_ desta função está obsoleta.

PADOFFSET find_rundefsvoffset ()

intro_meu
"Introduzir" "minhas" variáveis ​​ao status visível. Isso é chamado durante a análise em
o final de cada instrução para tornar as variáveis ​​lexicais visíveis para as subsequentes
afirmações.

U32 intro_my ()

módulo_carga
Carrega o módulo cujo nome é apontado pela parte string de nome. Observe que
o nome real do módulo, não seu nome de arquivo, deve ser fornecido. Por exemplo, "Foo :: Bar" ao invés
de "Foo / Bar.pm". sinalizadores podem ser PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT ou
PERL_LOADMOD_IMPORT_OPS (ou 0 para nenhum sinalizador). ver, se especificado e não NULL,
fornece semântica de versão semelhante a "use Foo :: Bar VERSION". O opcional
argumentos SV * finais podem ser usados ​​para especificar argumentos para o módulo importar()
método, semelhante a "use Foo :: Bar VERSION LIST". Eles devem ser encerrados com um
ponteiro NULL final. Observe que esta lista só pode ser omitida quando o
O sinalizador PERL_LOADMOD_NOIMPORT foi usado. Caso contrário, pelo menos um único NULL
é necessário um ponteiro para designar a lista de importação padrão.

A contagem de referência para cada parâmetro "SV *" especificado é diminuída.

void load_module (sinalizadores U32, nome SV *, SV * ver, ...)

novoPADNAMELIST
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Cria uma nova lista de nomes de pad. "max" é o índice mais alto para o qual o espaço é
alocado.

PADNAMELIST * newPADNAMELIST (size_t max)

novoPADNAMEouter
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Constrói e retorna um novo nome de pad. Use esta função apenas para nomes que
referem-se a léxicos externos. (Consulte também "newPADNAMEpvn".) exterior é o nome do pad externo
que este espelha. O nome do pad retornado já tem a bandeira PADNAMEt_OUTER
definido.

PADNAME * newPADNAMEouter (PADNAME * externo)

novoPADNAMEpvn
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Constrói e retorna um novo nome de pad. s deve ser uma string UTF8. Não use isto
para nomes de blocos que apontam para léxicos externos. Veja "newPADNAMEouter".

PADNAME * newPADNAMEpvn (const char * s, STRLEN len)

sem gancho
Stub que fornece gancho de thread para perl_destruct quando não há threads.

int nothreadhook ()

padnamelist_fetch
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Busca o nome do bloco no índice fornecido.

PADNAME * padnamelist_fetch (PADNAMELIST * pnl,
chave SSize_t)

padnamelist_store
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Armazena o nome do bloco (que pode ser nulo) no índice fornecido, liberando qualquer
nome do teclado nesse slot.

PADNAME ** padnamelist_store (PADNAMELIST * pnl,
SSize_t chave, PADNAME * val)

pad_add_anon
Aloca um lugar no bloco de compilação atual (via "pad_alloc") para um
função anônima com escopo léxico dentro da função de compilação
função. A função função está vinculado ao pad, e seu link "CvOUTSIDE" para
o escopo externo é enfraquecido para evitar um loop de referência.

Uma contagem de referência é roubada, então você pode precisar fazer "SvREFCNT_inc (func)".

tipo de opção deve ser um opcode indicando o tipo de operação que a entrada do teclado é
suportar. Isso não afeta a semântica operacional, mas é usado para depuração.

PADOFFSET pad_add_anon (CV * func, I32 optype)

pad_add_name_pv
Exatamente como "pad_add_name_pvn", mas leva uma string terminada em nulo em vez de um
par string / comprimento.

PADOFFSET pad_add_name_pv (const char * name, U32 flags,
HV * typestash, HV * ourstash)

pad_add_name_pvn
Aloca um local no bloco de compilação atual para uma variável lexical nomeada.
Armazena o nome e outros metadados na parte do nome do painel e torna
preparações para gerenciar o escopo léxico da variável. Retorna o deslocamento do
slot de almofada alocado.

nomepv/Namelen especifique o nome da variável, incluindo sigilo inicial. Se Typestash
não é nulo, o nome é para um léxico digitado e isso identifica o tipo. Se
nosso esconderijo não é nulo, é uma referência lexical a uma variável de pacote, e este
identifica o pacote. Os seguintes sinalizadores podem ser combinados com OR:

padadd_OUR especifica redundantemente se é um pacote var
A variável padadd_STATE irá reter o valor persistentemente
padadd_NO_DUP_CHECK ignorar verificação para sombreamento léxico

PADOFFSET pad_add_name_pvn (const char * namepv,
STRLEN namelen, sinalizadores U32,
HV * typestash, HV * ourstash)

pad_add_name_sv
Exatamente como "pad_add_name_pvn", mas leva a string de nome na forma de um SV
em vez de um par string / comprimento.

PADOFFSET pad_add_name_sv (nome SV *, sinalizadores U32,
HV * typestash, HV * ourstash)

pad_alloc
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Aloca um lugar no bloco de compilação atual, retornando o deslocamento do
slot de almofada alocado. Nenhum nome é inicialmente anexado ao slot de almofada. tipo tmp é um
conjunto de sinalizadores indicando o tipo de entrada de teclado necessária, que será definido no
valor SV para a entrada de teclado alocada:

SVs_PADMY denominada variável lexical ("meu", "nosso", "estado")
SVs_PADTMP armazenamento temporário sem nome
Constante SVf_READONLY compartilhada entre níveis de recursão

"SVf_READONLY" é suportado aqui apenas desde o perl 5.20. Para trabalhar mais cedo
versões também, use "SVf_READONLY | SVs_PADTMP". "SVf_READONLY" não causa
o SV no slot de pad deve ser marcado como somente leitura, mas simplesmente informa ao "pad_alloc" que
it precisarão ser feito somente leitura (pelo chamador), ou pelo menos deve ser tratado como tal.

tipo de opção deve ser um opcode indicando o tipo de operação que a entrada do teclado é
suportar. Isso não afeta a semântica operacional, mas é usado para depuração.

PADOFFSET pad_alloc (I32 optype, U32 tmptype)

pad_findmy_pv
Exatamente como "pad_findmy_pvn", mas leva uma string terminada em nulo em vez de um
par string / comprimento.

PADOFFSET pad_findmy_pv (const char * name, sinalizadores U32)

pad_findmy_pvn
Dado o nome de uma variável lexical, encontre sua posição na
almofada. nomepv/Namelen especifique o nome da variável, incluindo sigilo inicial. bandeiras
é reservado e deve ser zero. Se não estiver no bloco atual, mas aparecer no
pad de qualquer escopo lexicalmente envolvente, então uma pseudo-entrada para ele é adicionada no
pad atual. Retorna o deslocamento no pad atual, ou "NOT_IN_PAD" se não houver
lexical está no escopo.

PADOFFSET pad_findmy_pvn (const char * namepv,
STRLEN namelen, sinalizadores U32)

pad_findmy_sv
Exatamente como "pad_findmy_pvn", mas leva a string de nome na forma de um SV
em vez de um par string / comprimento.

PADOFFSET pad_findmy_sv (nome SV *, sinalizadores U32)

pad_setsv
Defina o valor no deslocamento po no pad atual (compilando ou executando). Use o
macro PAD_SETSV () em vez de chamar essa função diretamente.

void pad_setsv (PADOFFSET po, SV * sv)

pad_sv Obtém o valor no deslocamento po no pad atual (compilando ou executando). Use macro
PAD_SV em vez de chamar esta função diretamente.

SV * pad_sv (PADOFFSET po)

pad_tidy
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Arrume um bloco no final da compilação do código ao qual pertence. Empregos
executadas aqui são: remover a maioria das coisas dos protótipos do anonsub; dê
uma @_; marque os temporários como tais. tipo indica o tipo de sub-rotina:

padtidy_SUB sub-rotina comum
protótipo padtidy_SUBCLONE para fechamento lexical
formato padtidy_FORMAT

void pad_tidy (tipo padtidy_type)

perl_alloc
Aloca um novo interpretador Perl. Veja perlembed.

PerlInterpreter * perl_alloc ()

perl_construct
Inicializa um novo interpretador Perl. Veja perlembed.

void perl_construct (PerlInterpreter * my_perl)

perl_destruct
Encerra um interpretador Perl. Veja perlembed.

int perl_destruct (PerlInterpreter * my_perl)

perl_free
Libera um interpretador Perl. Veja perlembed.

void perl_free (PerlInterpreter * my_perl)

perl_parse
Diz a um interpretador Perl para analisar um script Perl. Veja perlembed.

int perl_parse (PerlInterpreter * my_perl,
XSINIT_t xsinit, int argc,
char ** argv, char ** env)

perl_run
Diz a um interpretador Perl para ser executado. Veja perlembed.

int perl_run (PerlInterpreter * my_perl)

exigir_pv
Diz ao Perl para "exigir" o arquivo nomeado pelo argumento string. É análogo a
o código Perl "eval" requer '$ file' "". É até implementado dessa forma; considerar
usando load_module em vez disso.

NOTA: a forma perl_ desta função está obsoleta.

void require_pv (const char * pv)

Exceção Manipulação (simples) Macros

dXCPT Configure as variáveis ​​locais necessárias para o tratamento de exceções. Consulte "Tratamento de exceções"
em perlguts.

dXCPT;

XCPT_CATCH
Introduz um bloco catch. Veja "Tratamento de exceções" em perlguts.

XCPT_RETHROW
Joga novamente uma exceção detectada anteriormente. Veja "Tratamento de exceções" em perlguts.

XCPT_RETHROW;

XCPT_TRY_END
Termina um bloco de teste. Veja "Tratamento de exceções" em perlguts.

XCPT_TRY_START
Inicia um bloco de teste. Veja "Tratamento de exceções" em perlguts.

Global Variáveis

Essas variáveis ​​são globais para um processo inteiro. Eles são compartilhados entre todos os intérpretes
e todos os threads em um processo.

PL_check
Array, indexado por opcode, de funções que serão chamadas para a fase de "verificação"
da construção do optree durante a compilação do código Perl. Para a maioria (mas não todos) os tipos
de op, uma vez que o op tenha sido inicialmente construído e preenchido com ops filhos, ele irá
ser filtrado através da função de verificação referenciada pelo elemento apropriado de
esta matriz. O novo op é passado como o único argumento para a função de verificação,
e a função de verificação retorna a operação concluída. A função de verificação pode (como o
o nome sugere) verifique o op quanto à validade e aos erros de sinal. Também pode
inicializar ou modificar partes das operações, ou realizar uma cirurgia mais radical, como
adicionar ou remover ops filho, ou até mesmo jogar o op fora e retornar um op diferente
em seu lugar.

Este conjunto de ponteiros de função é um lugar conveniente para se conectar à compilação
processo. Um módulo XS pode colocar sua própria função de verificação personalizada no lugar de qualquer um dos
os padrões, para influenciar a compilação de um tipo particular de op.
No entanto, uma função de verificação personalizada nunca deve substituir totalmente uma verificação padrão
(ou mesmo uma função de verificação personalizada de outro módulo). Um módulo
modificar a verificação deve ao invés embrulho a função de verificação preexistente. Um costume
A função de verificação deve ser seletiva sobre quando aplicar seu comportamento personalizado. No
caso usual em que ele decide não fazer nada de especial com uma operação, ele deve acorrentar
a função op preexistente. As funções de verificação estão, portanto, ligadas em uma cadeia, com o
verificador de base do núcleo no final.

Para segurança de thread, os módulos não devem gravar diretamente neste array. Em vez disso, use
a função "wrap_op_checker".

PL_keyword_plugin
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Ponteiro de função, apontando para uma função usada para lidar com palavras-chave estendidas. O
função deve ser declarada como

int keyword_plugin_function (pTHX_
char * keyword_ptr, STRLEN keyword_len,
OP ** op_ptr)

A função é chamada a partir do tokeniser, sempre que uma possível palavra-chave é vista.
"keyword_ptr" aponta para a palavra no buffer de entrada do analisador e "keyword_len"
dá seu comprimento; não tem terminação nula. Espera-se que a função examine
a palavra, e possivelmente outro estado, como% ^ H, para decidir se deseja
tratá-lo como uma palavra-chave estendida. Caso contrário, a função deve retornar
"KEYWORD_PLUGIN_DECLINE", e o processo normal do analisador continuará.

Se a função quiser lidar com a palavra-chave, ela primeiro deve analisar qualquer coisa
seguindo a palavra-chave que faz parte da sintaxe introduzida pela palavra-chave. Ver
"Interface Lexer" para obter detalhes.

Quando uma palavra-chave está sendo tratada, a função do plugin deve construir uma árvore de "OP"
estruturas, representando o código que foi analisado. A raiz da árvore deve ser
armazenado em * op_ptr. A função então retorna uma constante indicando a sintaxe
função da construção que analisou: "KEYWORD_PLUGIN_STMT" se for um
declaração completa ou "KEYWORD_PLUGIN_EXPR" se for uma expressão. Observe que um
construção de instrução não pode ser usada dentro de uma expressão (exceto via "do BLOCK" e
semelhante), e uma expressão não é uma declaração completa (requer pelo menos um
terminando ponto-e-vírgula).

Quando uma palavra-chave é tratada, a função do plugin também pode ter o lado (tempo de compilação)
efeitos. Ele pode modificar "% ^ H", definir funções e assim por diante. Normalmente, se o lado
efeitos são o objetivo principal de um manipulador, ele não deseja gerar nenhuma operação para
ser incluído na compilação normal. Neste caso, ainda é necessário
fornecem uma árvore de operações, mas é suficiente para gerar uma única operação nula.

É assim que a função * PL_keyword_plugin precisa se comportar de maneira geral.
Convencionalmente, no entanto, não se substitui completamente o manipulador existente
função. Em vez disso, faça uma cópia de "PL_keyword_plugin" antes de atribuir o seu próprio
apontador de função para ele. Sua função de manipulador deve procurar palavras-chave que sejam
interessado em lidar com eles. Onde não estiver interessado, deve chamar o
função de plugin salva, passando os argumentos que recebeu. Por isso
"PL_keyword_plugin" na verdade aponta para uma cadeia de funções de manipulador, todas as quais
têm a oportunidade de lidar com palavras-chave e apenas a última função da cadeia
(embutido no núcleo Perl) normalmente retornará "KEYWORD_PLUGIN_DECLINE".

GV Funções

Um GV é uma estrutura que corresponde a um typeglob Perl, ou seja, * foo. É uma estrutura
que contém um ponteiro para um escalar, um array, um hash etc, correspondendo a $ foo, @foo,% foo.

GVs são normalmente encontrados como valores em stashes (hashes de tabela de símbolos) onde Perl armazena seus
variáveis ​​globais.

GvAV Retorna o AV do GV.

AV * GvAV (GV * gv)

GvCV Retorna o CV do GV.

CV * GvCV (GV * gv)

GvHV Retorna o HV do GV.

HV * GvHV (GV * gv)

GvSV Retorna o SV do GV.

SV * GvSV (GV * gv)

gv_const_sv
Se "gv" for um typeglob cuja entrada de sub-rotina é uma sub constante elegível para
inlining ou "gv" é uma referência de espaço reservado que seria promovida a tal
typeglob e retorna o valor retornado pelo sub. Caso contrário, retorna NULL.

SV * gv_const_sv (GV * gv)

gv_fetchmeth
Como "gv_fetchmeth_pvn", mas não possui um parâmetro de sinalizadores.

GV * gv_fetchmeth (HV * stash, const char * name,
STRLEN len, nível I32)

gv_fetchmethod_autoload
Retorna o glob que contém a sub-rotina a ser chamada para invocar o método no
"esconder". Na verdade, na presença de carregamento automático, este pode ser o glob para
"AUTOLOAD". Neste caso, a variável correspondente $ AUTOLOAD já está configurada.

O terceiro parâmetro de "gv_fetchmethod_autoload" determina se AUTOLOAD
a pesquisa é realizada se o método fornecido não estiver presente: diferente de zero significa sim, olhe
para AUTOLOAD; zero significa não, não procure por AUTOLOAD. Chamar "gv_fetchmethod" é
equivalente a chamar "gv_fetchmethod_autoload" com um "autoload" diferente de zero
parâmetro.

Essas funções concedem token "SUPER" como um prefixo do nome do método. Observe que se
você deseja manter o glob retornado por um longo tempo, você precisa verificar se ele está sendo
"AUTOLOAD", pois posteriormente a chamada pode carregar uma subrotina diferente devido
para $ AUTOLOAD mudando seu valor. Use o globo criado como um efeito colateral para fazer
esta.

Essas funções têm os mesmos efeitos colaterais que "gv_fetchmeth" com "level == 0". O
aplica-se um aviso contra a passagem do GV ​​retornado por "gv_fetchmeth" para "call_sv"
igualmente a essas funções.

GV * gv_fetchmethod_autoload (HV * stash,
const char * name,
carregamento automático I32)

gv_fetchmeth_autoload
Esta é a forma antiga de "gv_fetchmeth_pvn_autoload", que não tem parâmetro de sinalizadores.

GV * gv_fetchmeth_autoload (HV * stash,
const char * name,
STRLEN len, nível I32)

gv_fetchmeth_pv
Exatamente como "gv_fetchmeth_pvn", mas leva uma string terminada em nulo em vez de um
par string / comprimento.

GV * gv_fetchmeth_pv (HV * stash, const char * name,
Nível I32, sinalizadores U32)

gv_fetchmeth_pvn
Retorna o glob com o "nome" fornecido e uma sub-rotina definida ou "NULL". O
glob vive no "stash" fornecido, ou nos stashes acessíveis via @ISA e
UNIVERSAL::.

O argumento "nível" deve ser 0 ou -1. Se "nível == 0", como um efeito colateral
cria um glob com o "nome" fornecido no "stash" fornecido que, no caso de
sucesso contém um apelido para a sub-rotina e configura informações de cache para este
globo.

Os únicos valores significativos para "sinalizadores" são GV_SUPER e SVf_UTF8.

GV_SUPER indica que queremos procurar o método nas superclasses do
"esconder".

O GV retornado de "gv_fetchmeth" pode ser uma entrada de cache do método, que não é
visível para o código Perl. Então, ao chamar "call_sv", você não deve usar o GV
diretamente; em vez disso, você deve usar o currículo do método, que pode ser obtido no
GV com a macro "GvCV".

GV * gv_fetchmeth_pvn (HV * stash, const char * name,
STRLEN len, nível I32,
Sinalizadores U32)

gv_fetchmeth_pvn_autoload
Igual a gv_fetchmeth_pvn (), mas também procura sub-rotinas carregadas automaticamente. Retorna um
glob para a sub-rotina.

Para uma sub-rotina carregada automaticamente sem um GV, criará um GV mesmo se "nível <0".
Para uma sub-rotina carregada automaticamente sem um stub, GvCV () do resultado pode ser zero.

Atualmente, o único valor significativo para "sinalizadores" é SVf_UTF8.

GV * gv_fetchmeth_pvn_autoload (HV * stash,
const char * name,
STRLEN len, nível I32,
Sinalizadores U32)

gv_fetchmeth_pv_autoload
Exatamente como "gv_fetchmeth_pvn_autoload", mas leva uma string terminada em nulo
em vez de um par string / comprimento.

GV * gv_fetchmeth_pv_autoload (HV * stash,
const char * name,
Nível I32, sinalizadores U32)

gv_fetchmeth_sv
Exatamente como "gv_fetchmeth_pvn", mas leva a string de nome na forma de um SV
em vez de um par string / comprimento.

GV * gv_fetchmeth_sv (HV * stash, SV * namesv,
Nível I32, sinalizadores U32)

gv_fetchmeth_sv_autoload
Exatamente como "gv_fetchmeth_pvn_autoload", mas leva a string de nome na forma de
um SV em vez de um par string / comprimento.

GV * gv_fetchmeth_sv_autoload (HV * stash, SV * namesv,
Nível I32, sinalizadores U32)

gv_init A forma antiga de gv_init_pvn (). Não funciona com strings UTF8, pois não tem
parâmetro sinalizadores. Se o parâmetro "multi" for definido, o sinalizador GV_ADDMULTI será
passado para gv_init_pvn ().

void gv_init (GV * gv, HV * stash, const char * nome,
STRLEN len, int multi)

gv_init_pv
Igual a gv_init_pvn (), mas leva uma string terminada em nulo para o nome em vez de
separar char * e parâmetros de comprimento.

void gv_init_pv (GV * gv, HV * stash, const char * nome,
Sinalizadores U32)

gv_init_pvn
Converte um escalar em um typeglob. Este é um tipo de vinho incoercível; atribuindo um
a referência a ele será atribuída a um de seus slots, em vez de sobrescrevê-lo como
acontece com typeglobs criados por SvSetSV. Converter qualquer escalar que seja SvOK ()
pode produzir resultados imprevisíveis e é reservado para uso interno do perl.

"gv" é o escalar a ser convertido.

"stash" é o stash / pacote pai, se houver.

"nome" e "len" fornecem o nome. O nome não deve ser qualificado; isto é, deve
não inclui o nome do pacote. Se "gv" é um elemento stash, é o responsável pela chamada
responsabilidade de garantir que o nome passado para esta função corresponda ao nome do
o elemento. Se não corresponder, a contabilidade interna do perl sairá do
sincronizar.

"sinalizadores" podem ser definidos como SVf_UTF8 se "nome" for uma string UTF8 ou o valor de retorno de
SvUTF8 (SV). Também pode receber a sinalização GV_ADDMULTI, o que significa fingir que
o GV já foi visto antes (ou seja, suprimir avisos "Usado uma vez").

void gv_init_pvn (GV * gv, HV * stash, const char * nome,
STRLEN len, sinalizadores U32)

gv_init_sv
Igual a gv_init_pvn (), mas leva um SV * para o nome em vez de um caractere separado *
e parâmetros de comprimento. "flags" não é usado no momento.

void gv_init_sv (GV * gv, HV * stash, SV * namesv,
Sinalizadores U32)

gv_stahpv
Retorna um ponteiro para o stash de um pacote especificado. Usa "strlen" para
determina o comprimento de "nome" e chama "gv_stashpvn ()".

HV * gv_stashpv (const char * name, I32 flags)

gv_stahpvn
Retorna um ponteiro para o stash de um pacote especificado. O parâmetro "namelen"
indica o comprimento do "nome", em bytes. "flags" é passado para
"gv_fetchpvn_flags ()", então se definido como "GV_ADD" então o pacote será criado se
ainda não existe. Se o pacote não existe e "sinalizadores" é 0 (ou qualquer
outra configuração que não cria pacotes), então NULL é retornado.

Sinalizadores podem ser um dos seguintes:

GV_ADD
SVf_UTF8
GV_NOADD_NOINIT
GV_NOINIT
GV_NOEXPAND
GV_ADDMG

Os mais importantes são provavelmente GV_ADD e SVf_UTF8.

Observe, o uso de "gv_stashsv" em vez de "gv_stashpvn" sempre que possível é fortemente
recomendado por motivos de desempenho.

HV * gv_stashpvn (const char * name, U32 namelen,
bandeiras I32)

gv_stahpvs
Como "gv_stashpvn", mas leva uma string literal em vez de um par string / comprimento.

HV * gv_stashpvs (const char * name, I32 create)

gv_stashsv
Retorna um ponteiro para o stash de um pacote especificado. Veja "gv_stashpvn".

Observe que esta interface é fortemente preferida em vez de "gv_stashpvn" para desempenho
razões.

HV * gv_stashsv (SV * sv, sinalizadores I32)

setdefout
Define PL_defoutgv, o identificador de arquivo padrão para saída, para o passado em typeglob.
Como PL_defoutgv "possui" uma referência em seu typeglob, a contagem de referência do
passado no typeglob é aumentado em um, e a contagem de referência do typeglob
para o qual PL_defoutgv aponta é diminuído em um.

void setdefout (GV * gv)

Handy Valores

Ponteiro Nullav Null AV.

(obsoleto - use "(AV *) NULL" ao invés)

Nullch Null caractere ponteiro. (Não está mais disponível quando "PERL_CORE" é definido.)

Nullcv Null CV apontador.

(obsoleto - use "(CV *) NULL" ao invés)

Ponteiro Nullhv Null HV.

(obsoleto - use "(HV *) NULL" ao invés)

Ponteiro Nullsv Null SV. (Não está mais disponível quando "PERL_CORE" é definido.)

Hash Manipulação Funções

Uma estrutura HV representa um hash Perl. Consiste principalmente em uma série de ponteiros, cada um
dos quais aponta para uma lista vinculada de estruturas HE. A matriz é indexada pelo hash
função da chave, de modo que cada lista vinculada representa todas as entradas de hash com o mesmo
valor hash. Cada HE contém um ponteiro para o valor real, mais um ponteiro para um HEK
estrutura que contém a chave e o valor hash.

cop_fetch_label
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Devolve a etiqueta colada a um policial. O ponteiro dos sinalizadores pode ser definido como "SVf_UTF8"
ou 0.

const char * cop_fetch_label (COP * const cop,
Sinalizadores STRLEN * len, U32 *)

cop_store_label
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Salve um rótulo em um "cop_hints_hash". Você precisa definir sinalizadores para "SVf_UTF8" para um
rótulo utf-8.

void cop_store_label (COP * const cop,
etiqueta const char *, STRLEN len,
Sinalizadores U32)

get_hv Retorna o HV do hash Perl especificado. "sinalizadores" são passados ​​para "gv_fetchpv".
Se "GV_ADD" for definido e a variável Perl não existir, ela será criada.
Se "sinalizadores" for zero e a variável não existir, NULL será retornado.

NOTA: a forma perl_ desta função está obsoleta.

HV * get_hv (const char * name, I32 flags)

HEf_SVKEY
Este sinalizador, usado no slot de comprimento de entradas hash e estruturas mágicas, especifica
a estrutura contém um ponteiro "SV *" onde um ponteiro "char *" é esperado.
(Apenas para informação - não deve ser usado).

HeHASH Retorna o hash calculado armazenado na entrada do hash.

U32 HeHASH (HE * he)

HeKEY Retorna o ponteiro real armazenado no slot de chave da entrada hash. O ponteiro
pode ser "char *" ou "SV *", dependendo do valor de "HeKLEN ()". Pode ser
atribuído a. As macros "HePV ()" ou "HeSVKEY ()" são geralmente preferíveis para
encontrar o valor de uma chave.

void * HeKEY (HE * he)

HeKLEN Se for negativo e corresponder a "HEf_SVKEY", indica que a entrada contém um
Tecla "SV *". Caso contrário, contém o comprimento real da chave. Pode ser atribuído a.
A macro "HePV ()" geralmente é preferível para localizar comprimentos de chave.

STRLEN HeKLEN (HE * ele)

HePV Retorna o slot de chave da entrada hash como um valor "char *", fazendo o que for necessário
desreferenciação de possíveis chaves "SV *". O comprimento da string é colocado em "len"
(esta é uma macro, então faça não use & len). Se você não se importa com o comprimento
da chave é, você pode usar a variável global "PL_na", embora isso seja um pouco menos
eficiente do que usar uma variável local. Lembre-se, porém, de que as chaves hash em perl
estão livres para conter nulos incorporados, então usar "strlen ()" ou similar não é uma boa
maneira de encontrar o comprimento das chaves hash. Isso é muito semelhante à macro "SvPV ()"
descrito em outra parte deste documento. Veja também "HeUTF8".

Se você estiver usando "HePV" para obter valores a serem passados ​​para "newSVpvn ()" para criar um novo SV,
você deve considerar o uso de "newSVhek (HeKEY_hek (he))", pois é mais eficiente.

char * HePV (HE * he, STRLEN len)

HeSVKEY Retorna a chave como um "SV *" ou "NULL" se a entrada hash não contiver um "SV *"
chave.

SV * HeSVKEY (HE * he)

HeSVKEY_force
Retorna a chave como um "SV *". Irá criar e devolver um mortal temporário "SV *" se
a entrada hash contém apenas uma chave "char *".

SV * HeSVKEY_force (HE * he)

EleSVKEY_set
Define a chave para um determinado "SV *", tomando cuidado para definir os sinalizadores apropriados para
indica a presença de uma chave "SV *", e retorna o mesmo "SV *".

SV * HeSVKEY_set (HE * he, SV * sv)

HeUTF8 Retorna se o valor "char *" retornado por "HePV" está codificado em UTF-8, fazendo
qualquer desreferenciação necessária de possíveis chaves "SV *". O valor retornado será 0
ou não-0, não necessariamente 1 (ou mesmo um valor com qualquer conjunto de bits baixos), então do não
atribuir cegamente isso a uma variável "bool", pois "bool" pode ser um typedef para "char".

U32 HeUTF8 (HE * he)

HeVAL Retorna o valor do slot (tipo "SV *") armazenado na entrada hash. Pode ser atribuído a.

SV * foo = HeVAL (hv);
HeVAL (hv) = sv;

SV * HeVAL (HE * he)

HvENAME Retorna o nome efetivo de um stash, ou NULL se não houver nenhum. O efetivo
name representa um local na tabela de símbolos onde este stash reside. Isto é
atualizado automaticamente quando os pacotes são aliasados ​​ou excluídos. Um esconderijo que não é
mais na tabela de símbolos não tem nome efetivo. Este nome é preferível a
"HvNAME" para uso em linearizações MRO e caches isa.

char * HvENAME (HV * stash)

HvENAMELEN
Retorna o comprimento do nome efetivo do stash.

STRLEN HvENAMELEN (HV * stash)

HvENAMEUTF8
Retorna verdadeiro se o nome efetivo estiver na codificação UTF8.

Unsigned char HvENAMEUTF8 (HV * stash)

HvNAME Retorna o nome do pacote de um stash, ou NULL se "stash" não for um stash. Ver
"SvSTASH", "CvSTASH".

char * HvNAME (HV * stash)

HvNAMELEN
Retorna o comprimento do nome do stash.

STRLEN HvNAMELEN (HV * stash)

HvNAMEUTF8
Retorna verdadeiro se o nome estiver na codificação UTF8.

Unsigned char HvNAMEUTF8 (HV * stash)

hv_assert
Verifique se um hash está em um estado internamente consistente.

void hv_assert (HV * hv)

hv_clear
Libera todos os elementos de um hash, deixando-o vazio. O equivalente XS de
"% hash = ()". Veja também "hv_undef".

Veja "av_clear" para uma observação sobre o hash possivelmente ser inválido no retorno.

void hv_clear (HV * hv)

hv_clear_placeholders
Limpa todos os marcadores de posição de um hash. Se um hash restrito tiver alguma de suas chaves
marcada como somente leitura e a chave é subsequentemente excluída, a chave não é realmente
excluído, mas é marcado atribuindo a ele um valor de & PL_sv_placeholder. Isso marca
portanto, será ignorado por operações futuras, como iteração sobre o hash, mas
ainda permitirá que o hash tenha um valor reatribuído à chave em algum futuro
ponto. Esta função limpa quaisquer dessas chaves de espaço reservado do hash. Ver
Hash :: Util :: lock_keys () para um exemplo de seu uso.

void hv_clear_placeholders (HV * hv)

hv_copy_hints_hv
Uma versão especializada de "newHVhv" para copiar "% ^ H". ohv deve ser um ponteiro para um
hash (que pode ter magia "% ^ H", mas geralmente não deve ser mágico) ou "NULL"
(interpretado como um hash vazio). O conteúdo de ohv é copiado para um novo hash, que
tem a magia específica de "% ^ H" adicionada a ele. Um ponteiro para o novo hash é retornado.

HV * hv_copy_hints_hv (HV * ohv)

hv_delete
Exclui um par chave / valor no hash. O SV do valor é removido do hash,
tornado mortal, e voltou para o chamador. O valor absoluto de "klen" é o
comprimento da chave. Se "klen" for negativo, assume-se que a chave está em
Unicode codificado em UTF-8. O valor dos "sinalizadores" normalmente será zero; se definido para
G_DISCARD então NULL será retornado. NULL também será retornado se a chave for
não encontrado.

SV * hv_delete (HV * hv, const char * key, I32 klen,
bandeiras I32)

hv_delete_ent
Exclui um par chave / valor no hash. O valor SV é removido do hash, feito
mortal, e voltou para o chamador. O valor dos "sinalizadores" normalmente será zero; E se
definido como G_DISCARD então NULL será retornado. NULL também será retornado se o
a chave não foi encontrada. "hash" pode ser um valor de hash pré-computado válido ou 0 para solicitar
para ser computado.

SV * hv_delete_ent (HV * hv, SV * keysv, sinalizadores I32,
Hash U32)

hv_existe
Retorna um booleano indicando se a chave hash especificada existe. O absoluto
valor de "klen" é o comprimento da chave. Se "klen" for negativo, a chave é
presume-se que esteja em Unicode codificado em UTF-8.

bool hv_exists (HV * hv, const char * key, I32 klen)

hv_exists_ent
Retorna um booleano indicando se a chave hash especificada existe. "hash" pode ser
um valor hash pré-computado válido ou 0 para solicitar que ele seja calculado.

bool hv_exists_ent (HV * hv, SV * keysv, hash U32)

hv_fetch
Retorna o SV que corresponde à chave especificada no hash. O absoluto
valor de "klen" é o comprimento da chave. Se "klen" for negativo, a chave é
presume-se que esteja em Unicode codificado em UTF-8. Se "lval" for definido, a busca será
parte de uma loja. Isso significa que se não houver valor no hash associado a
a chave fornecida, então uma é criada e um ponteiro para ela é retornado. O "SV *" isso
os pontos a podem ser atribuídos. Mas sempre verifique se o valor de retorno não é nulo
antes de desreferenciá-lo para um "SV *".

Consulte "Compreendendo a magia de Hashes e matrizes amarrados" em perlguts para obter mais
informações sobre como usar esta função em hashes vinculados.

SV ** hv_fetch (HV * hv, const char * key, I32 klen,
I32 valor)

hv_fetchs
Como "hv_fetch", mas leva uma string literal em vez de um par string / comprimento.

SV ** hv_fetchs (HV * tb, const char * key, I32 lval)

hv_fetch_ent
Retorna a entrada hash que corresponde à chave especificada no hash. "cerquilha"
deve ser um número hash pré-computado válido para a "chave" fornecida, ou 0 se você quiser
função para computá-lo. SE "lval" for definido, a busca fará parte de uma loja.
Certifique-se de que o valor de retorno não seja nulo antes de acessá-lo. O valor de retorno quando
"hv" é um hash vinculado é um ponteiro para um local estático, portanto, certifique-se de fazer uma cópia
da estrutura se você precisar armazená-lo em algum lugar.

Consulte "Compreendendo a magia de Hashes e matrizes amarrados" em perlguts para obter mais
informações sobre como usar esta função em hashes vinculados.

HE * hv_fetch_ent (HV * hv, SV * keysv, I32 lval,
Hash U32)

hv_fill Retorna o número de depósitos de hash que estão em uso. Esta função é
envolto pela macro "HvFILL".

Anteriormente, esse valor era sempre armazenado na estrutura HV, o que criou um
sobrecarga em cada hash (e quase todos os objetos) para algo que foi
Raramente usado. Agora nós o calculamos sob demanda na primeira vez que é necessário, e
armazene-o em cache se for caro repetir. O valor em cache é
atualizado por inserções e exclusões, mas (atualmente) descartado se o hash for
Dividido.

STRLEN hv_fill (HV * const hv)

hv_iterinit
Prepara um ponto de partida para percorrer uma tabela hash. Retorna o número de chaves em
o hash (ou seja, o mesmo que "HvUSEDKEYS (hv)"). O valor de retorno é atualmente apenas
significativo para hashes sem empate mágico.

NOTA: Antes da versão 5.004_65, "hv_iterinit" costumava retornar o número de hash
baldes que por acaso estão em uso. Se você ainda precisa desse valor esotérico, você pode
obtê-lo através da macro "HvFILL (hv)".

I32 hv_iterinit (HV * hv)

hv_iterkey
Retorna a chave da posição atual do iterador hash. Ver
"hv_iterinit".

char * hv_iterkey (HE * entry, I32 * retlen)

hv_iterkeysv
Retorna a chave como um "SV *" da posição atual do iterador de hash. O
o valor de retorno sempre será uma cópia mortal da chave. Veja também "hv_iterinit".

SV * hv_iterkeysv (entrada HE *)

hv_iternext
Retorna entradas de um iterador de hash. Veja "hv_iterinit".

Você pode chamar "hv_delete" ou "hv_delete_ent" na entrada hash que o iterador
atualmente aponta para, sem perder seu lugar ou invalidar seu iterador.
Observe que, neste caso, a entrada atual é excluída do hash com seu
iterador contendo a última referência a ele. Seu iterador está sinalizado para liberar o
entrada na próxima chamada para "hv_iternext", então você não deve descartar seu iterador
imediatamente, caso contrário, a entrada vazará - chame "hv_iternext" para acionar o recurso
desalocação.

HE * hv_iternext (HV * hv)

hv_iternextsv
Executa um "hv_iternext", "hv_iterkey" e "hv_iterval" em uma operação.

SV * hv_iternextsv (HV * hv, char ** chave, I32 * retlen)

hv_iternext_flags
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Retorna entradas de um iterador de hash. Veja "hv_iterinit" e "hv_iternext". O
o valor dos "sinalizadores" normalmente será zero; se HV_ITERNEXT_WANTPLACEHOLDERS for definido como
chaves de espaço reservado (para hashes restritos) serão devolvidas além do normal
chaves. Por padrão, os marcadores de posição são ignorados automaticamente. Atualmente um
placeholder é implementado com um valor que é & PL_sv_placeholder. Observe que o
implementação de marcadores de posição e hashes restritos pode mudar, e o
a implementação atualmente não é suficientemente abstraída para que qualquer mudança seja organizada.

HE * hv_iternext_flags (sinalizadores HV * hv, I32)

hv_iterval
Retorna o valor da posição atual do iterador de hash. Ver
"hv_iterkey".

SV * hv_iterval (entrada HV * hv, HE *)

hv_magic
Adiciona magia a um hash. Veja "sv_magic".

void hv_magic (HV * hv, GV * gv, int como)

hv_scalar
Avalia o hash no contexto escalar e retorna o resultado. Lida com magia quando
o hash está empatado.

SV * hv_scalar (HV * hv)

hv_store
Armazena um SV em um hash. A chave hash é especificada como "chave" e o valor absoluto
de "klen" é o comprimento da chave. Se "klen" for negativo, a chave é assumida como
estar em Unicode codificado em UTF-8. O parâmetro "hash" é o valor hash pré-computado;
se for zero, o Perl irá computá-lo.

O valor de retorno será NULL se a operação falhou ou se o valor não precisava
para ser realmente armazenado dentro do hash (como no caso de hashes vinculados). De outra forma
ele pode ser referenciado para obter o "SV *" original. Observe que o chamador é
responsável por incrementar adequadamente a contagem de referência de "val" antes do
chamada e diminuindo-o se a função retornou NULL. Efetivamente um sucesso
hv_store assume a propriedade de uma referência a "val". Isso geralmente é o que você
quer; um SV recém-criado tem uma contagem de referência de um, então, se tudo o que o seu código faz é
criar SVs e armazená-los em um hash, hv_store será o proprietário da única referência ao
novo SV, e seu código não precisa fazer mais nada para organizá-lo. hv_store é
não implementado como uma chamada para hv_store_ent e não cria um SV temporário para
a chave, então se seus dados de chave ainda não estiverem no formato SV, use hv_store em
preferência para hv_store_ent.

Consulte "Compreendendo a magia de Hashes e matrizes amarrados" em perlguts para obter mais
informações sobre como usar esta função em hashes vinculados.

SV ** hv_store (HV * hv, const char * chave, I32 klen,
SV * val, hash U32)

hv_stores
Como "hv_store", mas leva uma string literal em vez de um par string / comprimento e
omite o parâmetro hash.

SV ** hv_stores (HV * tb, const char * key,
NULLOK SV * val)

hv_store_ent
Armazena "val" em um hash. A chave hash é especificada como "chave". O parâmetro "hash"
é o valor de hash pré-computado; se for zero, o Perl irá computá-lo. O
o valor de retorno é a nova entrada hash assim criada. Será NULL se a operação
falhou ou se o valor não precisava ser realmente armazenado dentro do hash (como em
caso de hashes amarrados). Caso contrário, o conteúdo do valor de retorno pode ser
acessado usando o "He?" macros descritas aqui. Observe que o chamador é
responsável por incrementar adequadamente a contagem de referência de "val" antes do
chamada e diminuindo-o se a função retornou NULL. Efetivamente um sucesso
hv_store_ent assume a propriedade de uma referência a "val". Isso geralmente é o que você
quer; um SV recém-criado tem uma contagem de referência de um, então, se tudo o que o seu código faz é
criar SVs e armazená-los em um hash, hv_store será o proprietário da única referência ao
novo SV, e seu código não precisa fazer mais nada para organizá-lo. Observe que
hv_store_ent lê apenas a "chave"; ao contrário de "val", ele não se apropria dele,
portanto, manter a contagem de referência correta na "chave" é inteiramente responsabilidade do chamador
responsabilidade. hv_store não é implementado como uma chamada para hv_store_ent e
não crie um SV temporário para a chave, então, se seus dados de chave ainda não estiverem no SV
formulário, em seguida, use hv_store em preferência a hv_store_ent.

Consulte "Compreendendo a magia de Hashes e matrizes amarrados" em perlguts para obter mais
informações sobre como usar esta função em hashes vinculados.

HE * hv_store_ent (HV * hv, chave SV *, SV * val, hash U32)

hv_undef
Indefine o hash. O equivalente XS de "undef (% hash)".

Além de liberar todos os elementos do hash (como hv_clear ()), isso também libera
quaisquer dados auxiliares e armazenamento associados ao hash.

Veja "av_clear" para uma observação sobre o hash possivelmente ser inválido no retorno.

void hv_undef (HV * hv)

newHV Cria um novo HV. A contagem de referência é definida como 1.

HV * newHV ()

Gancho manipulação

Essas funções fornecem meios convenientes e seguros para threads de manipulação de variáveis ​​de gancho.

wrap_op_checker
Coloca uma função C na cadeia de funções de verificação para um tipo de operação especificado. Isto
é a maneira preferida de manipular o array "PL_check". opcode especifica qual
tipo de operação deve ser afetado. novo_verificador é um ponteiro para a função C que é
a ser adicionado à cadeia de verificação desse opcode, e old_checker_p aponta para o armazenamento
local onde um ponteiro para a próxima função na cadeia será armazenado. O
valor de novo_ponteiro é escrito na matriz "PL_check", enquanto o valor
anteriormente armazenado lá é escrito para * old_checker_p.

A função deve ser definida assim:

static OP * new_checker (pTHX_ OP * op) {...}

Ele deve ser chamado desta maneira:

new_checker (aTHX_ op)

old_checker_p deve ser definido assim:

estático Perl_check_t old_checker_p;

"PL_check" é global para um processo inteiro, e um módulo que deseja ligar o op
a verificação pode ser invocada mais de uma vez por processo, normalmente em
tópicos diferentes. Para lidar com essa situação, essa função é idempotente. O
local * old_checker_p deve inicialmente (uma vez por processo) conter um ponteiro nulo.
Variável AC de duração estática (declarada no escopo do arquivo, normalmente também marcada
"estático" para fornecer ligação interna) será inicializado implicitamente
apropriadamente, se não tiver um inicializador explícito. Esta função irá
só realmente modifica a cadeia de verificação se encontrar * old_checker_p para ser nulo. Isto
função também é thread-safe em pequena escala. Ele usa o bloqueio apropriado para
evite condições de corrida ao acessar "PL_check".

Quando esta função é chamada, a função referenciada por novo_verificador deve estar pronto
ser chamado, exceto para * old_checker_p sendo preenchido. Em uma situação de threading,
novo_verificador pode ser chamado imediatamente, mesmo antes que esta função seja retornada.
* old_checker_p será sempre devidamente definido antes novo_verificador é chamado. Se
novo_verificador decide não fazer nada de especial com uma op que é dada (que
é o caso usual para a maioria dos usos de gancho operacional de cheque), ele deve encadear o cheque
função referenciada por * old_checker_p.

Se você quiser influenciar a compilação de chamadas para uma sub-rotina específica, use
"cv_set_call_checker" ao invés de verificação de todas as operações "entersub".

void wrap_op_checker (Optype opcode,
Perl_check_t novo_checker,
Perl_check_t * old_checker_p)

Lexer interface

Esta é a camada inferior do analisador Perl, gerenciando personagens e tokens.

lex_bufutf8
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Indica se os octetos no buffer lexer ("PL_parser-> linestr") devem ser
interpretado como a codificação UTF-8 de caracteres Unicode. Se não, eles deveriam ser
interpretado como caracteres Latin-1. Isso é análogo ao sinalizador "SvUTF8" para
escalares.

No modo UTF-8, não é garantido que o buffer lexer realmente contenha
UTF-8. O código Lexing deve ser robusto em face da codificação inválida.

O sinalizador "SvUTF8" real do escalar "PL_parser-> linestr" é significativo, mas
não toda a história sobre a codificação de caracteres de entrada. Normalmente, quando um arquivo
está sendo lido, o escalar contém octetos e seu sinalizador "SvUTF8" está desligado, mas o
os octetos devem ser interpretados como UTF-8 se o pragma "use utf8" estiver em vigor.
Durante uma avaliação de string, no entanto, o escalar pode ter o sinalizador "SvUTF8" ativado e em
neste caso, seus octetos devem ser interpretados como UTF-8 a menos que o pragma "usar bytes"
está em vigor. Essa lógica pode mudar no futuro; use esta função em vez de
implementando a lógica você mesmo.

bool lex_bufutf8 ()

lex_discard_to
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Descarta a primeira parte do buffer "PL_parser-> linestr", até ptr. O
o conteúdo restante do buffer será movido, e todos os ponteiros para o buffer
atualizado apropriadamente. ptr não deve estar mais tarde no buffer do que a posição de
"PL_parser-> bufptr": não é permitido descartar o texto que ainda não foi lexedido.

Normalmente não é necessário fazer isso diretamente, porque basta usar o
comportamento de descarte implícito de "lex_next_chunk" e coisas baseadas nele.
No entanto, se um token se estende por várias linhas e o código lexing manteve
várias linhas de texto no buffer para esse fim, depois da conclusão de
o token, seria aconselhável descartar explicitamente as linhas anteriores, agora desnecessárias,
para evitar que futuros tokens multilinhas aumentem o buffer sem limites.

void lex_discard_to (char * ptr)

lex_grow_linestr
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Realoca o buffer lexer ("PL_parser-> linestr") para acomodar pelo menos len
octetos (incluindo a terminação de "NUL"). Retorna um ponteiro para o realocado
amortecedor. Isso é necessário antes de fazer qualquer modificação direta no buffer
isso aumentaria seu comprimento. "lex_stuff_pvn" oferece uma maneira mais conveniente de
inserir texto no buffer.

Não use "SvGROW" ou "sv_grow" diretamente em "PL_parser-> linestr"; esta função
atualiza todas as variáveis ​​do lexer que apontam diretamente para o buffer.

char * lex_grow_linestr (STRLEN len)

lex_next_chunk
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Lê no próximo pedaço de texto a ser lexed, acrescentando-o a "PL_parser-> linestr".
Deve ser chamado quando o código lexing olhou para o final do trecho atual
e quer saber mais. É normal, mas não necessário, que o lexing tenha
consumiu todo o pedaço atual neste momento.

Se "PL_parser-> bufptr" estiver apontando para o final do bloco atual (ou seja, o
o pedaço atual foi totalmente consumido), normalmente o pedaço atual será
descartado ao mesmo tempo em que o novo bloco é lido. bandeiras inclui
"LEX_KEEP_PREVIOUS", o trecho atual não será descartado. Se o atual
pedaço não foi totalmente consumido, então não será descartado independentemente de
a bandeira.

Retorna verdadeiro se algum novo texto foi adicionado ao buffer, ou falso se o buffer foi
chegou ao final do texto de entrada.

bool lex_next_chunk (sinalizadores U32)

lex_peek_unichar
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Procura um caractere (Unicode) no texto que está sendo lexificado. Devoluções
o ponto de código (valor inteiro sem sinal) do próximo caractere, ou -1 se lexing tiver
chegou ao final do texto de entrada. Para consumir o personagem espiado, use
"lex_read_unichar".

Se o próximo caractere estiver (ou se estender) no próximo bloco de texto de entrada, o
o próximo bloco será lido. Normalmente, o bloco atual será descartado no
mesmo tempo, mas se bandeiras inclui "LEX_KEEP_PREVIOUS" então o bloco atual irá
não ser descartado.

Se a entrada está sendo interpretada como UTF-8 e um erro de codificação UTF-8 é
encontrado, uma exceção é gerada.

I32 lex_peek_unichar (sinalizadores U32)

lex_read_space
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Lê espaços opcionais, no estilo Perl, no texto atualmente sendo lexed. O
os espaços podem incluir caracteres de espaço em branco comuns e comentários no estilo Perl.
As diretivas "#line" são processadas se encontradas. "PL_parser-> bufptr" foi movido
além dos espaços, de modo que aponte para um caractere sem espaço (ou o final do
Entrada de texto).

Se os espaços se estendem até a próxima parte do texto de entrada, a próxima parte será lida
in. Normalmente, o bloco atual será descartado ao mesmo tempo, mas se bandeiras
inclui "LEX_KEEP_PREVIOUS" então o bloco atual não será descartado.

void lex_read_space (sinalizadores U32)

lex_read_to
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Consumir texto no buffer lexer, de "PL_parser-> bufptr" até ptr. Este
avança "PL_parser-> bufptr" para corresponder ptr, realizando a contabilidade correta
sempre que um caractere de nova linha é passado. Esta é a maneira normal de consumir lexed
texto.

A interpretação dos octetos do buffer pode ser abstraída usando o ligeiro
funções de nível superior "lex_peek_unichar" e "lex_read_unichar".

void lex_read_to (char * ptr)

lex_read_unichar
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Lê o próximo caractere (Unicode) no texto que está sendo convertido. Retorna o
ponto de código (valor inteiro sem sinal) do caractere lido e se move
"PL_parser-> bufptr" após o caractere, ou retorna -1 se lexing atingiu o
final do texto de entrada. Para examinar não destrutivamente o próximo personagem, use
"lex_peek_unichar" em vez disso.

Se o próximo caractere estiver (ou se estender) no próximo bloco de texto de entrada, o
o próximo bloco será lido. Normalmente, o bloco atual será descartado no
mesmo tempo, mas se bandeiras inclui "LEX_KEEP_PREVIOUS" então o bloco atual irá
não ser descartado.

Se a entrada está sendo interpretada como UTF-8 e um erro de codificação UTF-8 é
encontrado, uma exceção é gerada.

I32 lex_read_unichar (sinalizadores U32)

lex_start
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Cria e inicializa um novo objeto de estado lexer / parser, fornecendo um contexto em
que lexar e analisar a partir de uma nova fonte de código Perl. Um ponteiro para o novo estado
objeto é colocado em "PL_parser". Uma entrada é feita na pilha de salvamento para que após
desenrolar o novo objeto de estado será destruído e o valor anterior de
"PL_parser" será restaurado. Nada mais precisa ser feito para limpar a análise
contexto.

O código a ser analisado vem de linha e RSFP. linha, se não nulo, fornece um
string (no formato SV) contendo o código a ser analisado. Uma cópia da string é feita,
então modificação subsequente de linha não afeta a análise. RSFP, se não nulo,
fornece um fluxo de entrada a partir do qual o código será lido para ser analisado. Se ambos são
não nulo, o código em linha vem primeiro e deve consistir em linhas completas de
entrada, e RSFP fornece o restante da fonte.

A bandeiras parâmetro é reservado para uso futuro. Atualmente só é usado por perl
internamente, portanto, as extensões devem sempre passar de zero.

void lex_start (linha SV *, PerlIO * rsfp, sinalizadores U32)

lex_stuff_pv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Insira caracteres no buffer lexer ("PL_parser-> linestr"), imediatamente após
o ponto lexing atual ("PL_parser-> bufptr"), realocando o buffer se
necessário. Isso significa que o código lexing executado posteriormente verá os caracteres como
se eles tivessem aparecido na entrada. Não é recomendado fazer isso como parte de
análise normal, e a maioria dos usos deste recurso corre o risco de o
personagens sendo interpretados de maneira não intencional.

A string a ser inserida é representada por octetos começando em pv e continuando
para o primeiro nul. Esses octetos são interpretados como UTF-8 ou Latin-1,
de acordo com se o sinalizador "LEX_STUFF_UTF8" está definido em bandeiras. Os personagens
são recodificados para o buffer lexer, de acordo com como o buffer está sendo
interpretado ("lex_bufutf8"). Se não for conveniente anular uma string para
ser inserido, a função "lex_stuff_pvn" é mais apropriada.

void lex_stuff_pv (const char * pv, sinalizadores U32)

lex_stuff_pvn
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Insira caracteres no buffer lexer ("PL_parser-> linestr"), imediatamente após
o ponto lexing atual ("PL_parser-> bufptr"), realocando o buffer se
necessário. Isso significa que o código lexing executado posteriormente verá os caracteres como
se eles tivessem aparecido na entrada. Não é recomendado fazer isso como parte de
análise normal, e a maioria dos usos deste recurso corre o risco de o
personagens sendo interpretados de maneira não intencional.

A string a ser inserida é representada por len octetos começando em pv. Estes
octetos são interpretados como UTF-8 ou Latin-1, de acordo com o
A sinalização "LEX_STUFF_UTF8" está definida em bandeiras. Os caracteres são recodificados para o lexer
buffer, de acordo com como o buffer está sendo interpretado
("lex_bufutf8"). Se uma string a ser inserida estiver disponível como um escalar Perl, o
A função "lex_stuff_sv" é mais conveniente.

void lex_stuff_pvn (const char * pv, STRLEN len,
Sinalizadores U32)

lex_stuff_pvs
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Como "lex_stuff_pvn", mas leva uma string literal em vez de um par string / comprimento.

void lex_stuff_pvs (const char * pv, sinalizadores U32)

lex_stuff_sv
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Insira caracteres no buffer lexer ("PL_parser-> linestr"), imediatamente após
o ponto lexing atual ("PL_parser-> bufptr"), realocando o buffer se
necessário. Isso significa que o código lexing executado posteriormente verá os caracteres como
se eles tivessem aparecido na entrada. Não é recomendado fazer isso como parte de
análise normal, e a maioria dos usos deste recurso corre o risco de o
personagens sendo interpretados de maneira não intencional.

A string a ser inserida é o valor da string de sv. Os personagens são recodificados
para o buffer lexer, de acordo com como o buffer está sendo interpretado
("lex_bufutf8"). Se uma string a ser inserida ainda não for um escalar Perl, o
A função "lex_stuff_pvn" evita a necessidade de construir um escalar.

void lex_stuff_sv (SV * sv, sinalizadores U32)

lex_unstuff
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Descarta o texto prestes a ser lexed, de "PL_parser-> bufptr" até ptr. Texto
seguinte ptr será movido e o buffer encurtado. Isso esconde o descartado
texto de qualquer código lexing executado posteriormente, como se o texto nunca tivesse aparecido.

Esta não é a maneira normal de consumir texto lexificado. Para isso, use "lex_read_to".

void lex_unstuff (char * ptr)

parse_arithexpr
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa uma expressão aritmética Perl. Isso pode conter operadores de precedência para baixo
para os operadores de bit shift. A expressão deve ser seguida (e, portanto, encerrada)
por um operador de comparação ou de precedência inferior ou por algo que
normalmente termina uma expressão como ponto e vírgula. Se bandeiras inclui
"PARSE_OPTIONAL" então a expressão é opcional, caso contrário, é obrigatória. Isto
cabe ao chamador garantir que o estado do analisador dinâmico ("PL_parser" et al) seja
definido corretamente para refletir a fonte do código a ser analisado e o léxico
contexto para a expressão.

A árvore op que representa a expressão é retornada. Se uma expressão opcional for
ausente, um ponteiro nulo é retornado, caso contrário, o ponteiro não será nulo.

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida é
voltou de qualquer maneira. O erro é refletido no estado do analisador, normalmente resultando
em uma única exceção no nível superior de análise que cobre toda a compilação
erros que ocorreram. Alguns erros de compilação, no entanto, lançam uma exceção
imediatamente.

OP * parse_arithexpr (sinalizadores U32)

parse_barestmt
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa uma única instrução Perl sem adornos. Isso pode ser um imperativo normal
declaração ou uma declaração que tem efeito de tempo de compilação. Não inclui nenhum
etiqueta ou outra fixação. Cabe ao chamador garantir que a dinâmica
estado do analisador ("PL_parser" et al) está configurado corretamente para refletir a fonte do
o código a ser analisado e o contexto léxico da instrução.

A árvore op que representa a declaração é retornada. Este pode ser um ponteiro nulo se
a instrução é nula, por exemplo, se for realmente uma definição de sub-rotina
(que tem efeitos colaterais em tempo de compilação). Se não for nulo, será ops diretamente
implementar a instrução, adequado para passar para "newSTATEOP". Não vai
normalmente incluem um "nextstate" ou operação equivalente (exceto para aqueles incorporados em um
escopo contido inteiramente na declaração).

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida (a maioria
provavelmente nulo) é retornado de qualquer maneira. O erro é refletido no estado do analisador,
normalmente resultando em uma única exceção no nível superior de análise que abrange
todos os erros de compilação que ocorreram. Alguns erros de compilação, no entanto,
lance uma exceção imediatamente.

A bandeiras O parâmetro é reservado para uso futuro e deve ser sempre zero.

OP * parse_barestmt (sinalizadores U32)

parse_block
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa um único bloco de código Perl completo. Consiste em uma chave de abertura, um
sequência de instruções e uma chave de fechamento. O bloco constitui um léxico
escopo, então "minhas" variáveis ​​e vários efeitos de tempo de compilação podem estar contidos dentro
isto. Cabe ao chamador garantir que o estado do analisador dinâmico ("PL_parser"
et al) está definido corretamente para refletir a fonte do código a ser analisado e o
contexto léxico para a declaração.

A árvore op que representa o bloco de código é retornada. Esta é sempre uma operação real,
nunca um ponteiro nulo. Normalmente será uma lista "lineseq", incluindo "nextstate"
ou ops equivalentes. Nenhuma operação para construir qualquer tipo de escopo de tempo de execução é incluída por
virtude de ser um bloco.

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida (a maioria
provavelmente nulo) é retornado de qualquer maneira. O erro é refletido no estado do analisador,
normalmente resultando em uma única exceção no nível superior de análise que abrange
todos os erros de compilação que ocorreram. Alguns erros de compilação, no entanto,
lance uma exceção imediatamente.

A bandeiras O parâmetro é reservado para uso futuro e deve ser sempre zero.

OP * parse_block (sinalizadores U32)

parse_fullexpr
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa uma única expressão Perl completa. Isso permite a gramática de expressão completa,
incluindo os operadores de precedência mais baixa, como "ou". A expressão deve ser
seguido (e, portanto, encerrado) por um token de que uma expressão normalmente seria
terminado por: fim do arquivo, pontuação de fechamento entre colchetes, ponto e vírgula ou um dos
as palavras-chave que sinalizam um modificador de instrução de expressão pós-fixada. Se bandeiras
inclui "PARSE_OPTIONAL" então a expressão é opcional, caso contrário, é
obrigatoriedade. Cabe ao chamador garantir que o estado do analisador dinâmico
("PL_parser" et al) está configurado corretamente para refletir a fonte do código a ser
analisado e o contexto léxico para a expressão.

A árvore op que representa a expressão é retornada. Se uma expressão opcional for
ausente, um ponteiro nulo é retornado, caso contrário, o ponteiro não será nulo.

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida é
voltou de qualquer maneira. O erro é refletido no estado do analisador, normalmente resultando
em uma única exceção no nível superior de análise que cobre toda a compilação
erros que ocorreram. Alguns erros de compilação, no entanto, lançam uma exceção
imediatamente.

OP * parse_fullexpr (sinalizadores U32)

parse_fullstmt
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa uma única instrução Perl completa. Esta pode ser uma declaração imperativa normal
ou uma declaração que tem efeito de tempo de compilação e pode incluir rótulos opcionais.
Cabe ao chamador garantir que o estado do analisador dinâmico ("PL_parser" et al)
está configurado corretamente para refletir a fonte do código a ser analisado e o léxico
contexto para a declaração.

A árvore op que representa a declaração é retornada. Este pode ser um ponteiro nulo se
a instrução é nula, por exemplo, se for realmente uma definição de sub-rotina
(que tem efeitos colaterais em tempo de compilação). Se não for nulo, será o resultado de um
chamada "newSTATEOP", normalmente incluindo um "nextstate" ou op equivalente.

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida (a maioria
provavelmente nulo) é retornado de qualquer maneira. O erro é refletido no estado do analisador,
normalmente resultando em uma única exceção no nível superior de análise que abrange
todos os erros de compilação que ocorreram. Alguns erros de compilação, no entanto,
lance uma exceção imediatamente.

A bandeiras O parâmetro é reservado para uso futuro e deve ser sempre zero.

OP * parse_fullstmt (sinalizadores U32)

parse_label
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa um único rótulo, possivelmente opcional, do tipo que pode prefixar um Perl
declaração. Cabe ao chamador garantir que o estado do analisador dinâmico
("PL_parser" et al) está configurado corretamente para refletir a fonte do código a ser
analisado. Se bandeiras inclui "PARSE_OPTIONAL" então o rótulo é opcional, caso contrário
é obrigatório.

O nome do rótulo é retornado na forma de um escalar novo. Se um opcional
rótulo está ausente, um ponteiro nulo é retornado.

Se ocorrer um erro na análise, o que só pode ocorrer se o rótulo for obrigatório, um
etiqueta válida é retornada de qualquer maneira. O erro é refletido no estado do analisador,
normalmente resultando em uma única exceção no nível superior de análise que abrange
todos os erros de compilação que ocorreram.

SV * parse_label (sinalizadores U32)

parse_listexpr
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa uma expressão de lista Perl. Isso pode conter operadores de precedência até
o operador vírgula. A expressão deve ser seguida (e, portanto, encerrada)
por um operador lógico de baixa precedência, como "ou" ou por algo que
normalmente termina uma expressão como ponto e vírgula. Se bandeiras inclui
"PARSE_OPTIONAL" então a expressão é opcional, caso contrário, é obrigatória. Isto
cabe ao chamador garantir que o estado do analisador dinâmico ("PL_parser" et al) seja
definido corretamente para refletir a fonte do código a ser analisado e o léxico
contexto para a expressão.

A árvore op que representa a expressão é retornada. Se uma expressão opcional for
ausente, um ponteiro nulo é retornado, caso contrário, o ponteiro não será nulo.

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida é
voltou de qualquer maneira. O erro é refletido no estado do analisador, normalmente resultando
em uma única exceção no nível superior de análise que cobre toda a compilação
erros que ocorreram. Alguns erros de compilação, no entanto, lançam uma exceção
imediatamente.

OP * parse_listexpr (sinalizadores U32)

parse_stmtseq
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa uma sequência de zero ou mais instruções Perl. Isso pode ser um imperativo normal
declarações, incluindo rótulos opcionais ou declarações que têm tempo de compilação
efeito, ou qualquer mistura destes. A sequência de instruções termina quando uma chave de fechamento
ou o fim do arquivo é encontrado em um lugar onde uma nova declaração poderia ter validamente
iniciado. Cabe ao chamador garantir que o estado do analisador dinâmico
("PL_parser" et al) está configurado corretamente para refletir a fonte do código a ser
analisado e o contexto léxico para as instruções.

A árvore op que representa a seqüência de instruções é retornada. Isso pode ser nulo
ponteiro se as instruções forem todas nulas, por exemplo, se não houver instruções
ou se houvesse apenas definições de sub-rotina (que têm lado em tempo de compilação
efeitos). Se não for nulo, será uma lista "lineseq", normalmente incluindo
"nextstate" ou operações equivalentes.

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida é
voltou de qualquer maneira. O erro é refletido no estado do analisador, normalmente resultando
em uma única exceção no nível superior de análise que cobre toda a compilação
erros que ocorreram. Alguns erros de compilação, no entanto, lançam uma exceção
imediatamente.

A bandeiras O parâmetro é reservado para uso futuro e deve ser sempre zero.

OP * parse_stmtseq (sinalizadores U32)

parse_termexpr
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Analisa uma expressão de termo Perl. Isso pode conter operadores de precedência até
os operadores de atribuição. A expressão deve ser seguida (e, portanto, encerrada)
por uma vírgula ou operador de precedência inferior ou por algo que normalmente
terminar uma expressão como ponto-e-vírgula. Se bandeiras inclui "PARSE_OPTIONAL"
então a expressão é opcional, caso contrário, é obrigatória. Depende do
chamador para garantir que o estado do analisador dinâmico ("PL_parser" et al) está correto
definido para refletir a fonte do código a ser analisado e o contexto léxico para o
expressão.

A árvore op que representa a expressão é retornada. Se uma expressão opcional for
ausente, um ponteiro nulo é retornado, caso contrário, o ponteiro não será nulo.

Se ocorrer um erro na análise ou compilação, na maioria dos casos, uma árvore op válida é
voltou de qualquer maneira. O erro é refletido no estado do analisador, normalmente resultando
em uma única exceção no nível superior de análise que cobre toda a compilação
erros que ocorreram. Alguns erros de compilação, no entanto, lançam uma exceção
imediatamente.

OP * parse_termexpr (sinalizadores U32)

PL_parser
Ponteiro para uma estrutura que encapsula o estado da operação de análise atualmente
em andamento. O ponteiro pode ser alterado localmente para realizar uma análise aninhada sem
interferindo no estado de uma análise externa. Membros individuais de "PL_parser"
têm sua própria documentação.

PL_parser-> bufend
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Ponteiro direto para o final do pedaço de texto que está sendo lexedido, o final de
o buffer lexer. Isso é igual a "SvPVX (PL_parser-> linestr) +
SvCUR (PL_parser-> linestr) ". Um caractere" NUL "(octeto zero) está sempre localizado em
o final do buffer e não conta como parte do conteúdo do buffer.

PL_parser-> bufptr
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Aponta para a posição atual de lexing dentro do buffer lexer. Personagens
em torno deste ponto podem ser examinados livremente, dentro do intervalo delimitado por
"SvPVX (" PL_parser-> linestr ")" e "PL_parser-> bufend". Os octetos do buffer
pode ser interpretado como UTF-8 ou Latin-1, conforme indicado por
"lex_bufutf8".

O código Lexing (seja no núcleo Perl ou não) move este ponteiro além do
caracteres que ele consome. Prevê-se também a realização de alguma escrituração
sempre que um caractere de nova linha é consumido. Este movimento pode ser mais convenientemente
executado pela função "lex_read_to", que lida com novas linhas de forma adequada.

A interpretação dos octetos do buffer pode ser abstraída usando o ligeiro
funções de nível superior "lex_peek_unichar" e "lex_read_unichar".

PL_parser-> linestart
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Aponta para o início da linha atual dentro do buffer lexer. Isso é útil
para indicar em qual coluna ocorreu um erro, e nada mais. Isto deve ser
atualizado por qualquer código lexing que consome uma nova linha; a função "lex_read_to"
lida com esse detalhe.

PL_parser-> linestr
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Escalar do buffer contendo o trecho atualmente sob consideração do texto
atualmente sendo lexed. Este é sempre um escalar de string simples (para o qual "SvPOK" é
verdadeiro). Não se destina a ser usado como um escalar por meios escalares normais; em vez de
consulte o buffer diretamente pelas variáveis ​​de ponteiro descritas a seguir.

O lexer mantém vários ponteiros "char *" para coisas no "PL_parser-> linestr"
amortecedor. Se "PL_parser-> linestr" for realocado, todos esses ponteiros devem
ser atualizado. Não tente fazer isso manualmente, mas use "lex_grow_linestr"
se você precisar realocar o buffer.

O conteúdo do bloco de texto no buffer é normalmente exatamente uma linha completa
de entrada, até e incluindo um terminador de nova linha, mas há situações em que
é o contrário. Os octetos do buffer podem ser interpretados como
UTF-8 ou Latin-1. A função "lex_bufutf8" informa qual. Não use
o sinalizador "SvUTF8" neste escalar, que pode discordar dele.

Para exame direto do buffer, a variável "PL_parser-> bufend" aponta para
o fim do buffer. A posição lexing atual é apontada por
"PL_parser-> bufptr". O uso direto desses indicadores é geralmente preferível a
exame do escalar por meios escalares normais.

Relacionado à localidade funções e macros

DECLARATION_FOR_LC_NUMERIC_MANIPULATION
Esta macro deve ser usada como uma declaração. Ele declara uma variável privada (cuja
nome começa com um sublinhado) que é necessário para as outras macros neste
seção. Deixar de incluir isso corretamente deve levar a um erro de sintaxe. Por
compatibilidade com compiladores C89 C, deve ser colocado em um bloco antes de qualquer
declarações executáveis.

vazio DECLARATION_FOR_LC_NUMERIC_MANIPULATION

RESTORE_LC_NUMERIC
Isso é usado em conjunto com uma das macros
"STORE_LC_NUMERIC_SET_TO_NEEDED" e "STORE_LC_NUMERIC_FORCE_TO_UNDERLYING"

para restaurar adequadamente o estado "LC_NUMERIC".

Uma chamada para "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" deve ter sido feita para declarar
em tempo de compilação uma variável privada usada por esta macro e as duas "STORE".
Esta macro deve ser chamada como uma única instrução, não uma expressão, mas com um
lista de argumentos vazia, como esta:

{
DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
...
RESTORE_LC_NUMERIC ();
...
}

vazio RESTORE_LC_NUMERIC ()

STORE_LC_NUMERIC_FORCE_TO_UNDERLYING
Isso é usado pelo código XS que reconhece a localidade "LC_NUMERIC" para forçar a localidade
para a categoria "LC_NUMERIC" ser o que perl pensa ser o local subjacente atual.
(O interpretador de perl pode estar errado sobre o que a localidade subjacente realmente é
se algum código C ou XS chamou a função de biblioteca C definir local(3) atrás de seu
costas; chamar "sync_locale" antes de chamar esta macro atualizará os registros do perl.)

Uma chamada para "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" deve ter sido feita para declarar
em tempo de compilação, uma variável privada usada por esta macro. Esta macro deve ser
chamado como uma única instrução, não uma expressão, mas com uma lista de argumentos vazia,
como isso:

{
DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
...
STORE_LC_NUMERIC_FORCE_TO_UNDERLYING ();
...
RESTORE_LC_NUMERIC ();
...
}

A variável privada é usada para salvar o estado local atual, para que o
a chamada de correspondência necessária para "RESTORE_LC_NUMERIC" pode restaurá-lo.

vazio STORE_LC_NUMERIC_FORCE_TO_UNDERLYING ()

STORE_LC_NUMERIC_SET_TO_NEEDED
Isso é usado para ajudar a encapsular o código XS ou C que reconhece a localidade "LC_NUMERIC".
Esta categoria de localidade geralmente é mantida definida para a localidade C pelo Perl para trás
compatibilidade, e porque a maioria dos códigos XS que lêem valores de ponto flutuante pode lidar
apenas com o caractere de base decimal sendo um ponto.

Esta macro garante que o estado atual "LC_NUMERIC" esteja definido corretamente, para estar ciente
de localidade se a chamada para o código XS ou C do programa Perl for de dentro do
escopo de uma "localidade de uso"; ou ignorar a localidade se a chamada for externa
tal escopo.

Essa macro é o início do encapsulamento do código C ou XS; o final do wrap é feito por
chamando a macro "RESTORE_LC_NUMERIC" após a operação. Caso contrário, o estado
pode ser alterado que afetará adversamente outro código XS.

Uma chamada para "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" deve ter sido feita para declarar
em tempo de compilação, uma variável privada usada por esta macro. Esta macro deve ser
chamado como uma única instrução, não uma expressão, mas com uma lista de argumentos vazia,
como isso:

{
DECLARATION_FOR_LC_NUMERIC_MANIPULATION;
...
STORE_LC_NUMERIC_SET_TO_NEEDED();
...
RESTORE_LC_NUMERIC ();
...
}

vazio STORE_LC_NUMERIC_SET_TO_NEEDED()

sincronizar_locale
A alteração da localidade do programa deve ser evitada pelo código XS. Mesmo assim, certos
bibliotecas não-Perl chamadas de XS, como "Gtk", fazem isso. Quando isso acontece, Perl
precisa ser informado de que a localidade mudou. Use esta função para fazer isso, antes de
voltando para Perl.

voidsync_locale()

Mágico Funções

mg_clear
Limpe algo mágico que o SV representa. Veja "sv_magic".

int mg_clear(SV*sv)

mg_copy Copia a mágica de um SV para outro. Veja "sv_magic".

int mg_copy(SV *sv, SV *nsv, const char *chave,
I32 klen)

mg_find Localiza o ponteiro mágico para o tipo correspondente ao SV. Veja "sv_magic".

MAGIC* mg_find(const SV* sv, tipo int)

mg_findext
Localiza o ponteiro mágico de "tipo" com o "vtbl" fornecido para o "SV". Ver
"sv_magicext".

MAGIC* mg_findext(const SV* sv, tipo int,
constMGVTBL *vtbl)

mg_free Libera qualquer armazenamento mágico usado pelo SV. Veja "sv_magic".

int mg_free(SV*sv)

mg_free_type
Remova qualquer tipo de magia como do SV sv. Veja "sv_magic".

void mg_free_type(SV *sv, int como)

mg_get Faça mágica antes que um valor seja recuperado do SV. O tipo de SV deve ser >=
SVt_PVMG. Veja "sv_magic".

int mg_get(SV*sv)

mg_comprimento
DESCONTINUADA! É planejado remover esta função de uma versão futura do Perl.
Não o use para novo código; remova-o do código existente.

Relata o comprimento do SV em bytes, chamando length magic se disponível, mas não
não definir o sinalizador UTF8 no sv. Ele voltará a 'obter' magia se não houver
magia 'comprimento', mas sem indicação se chamava magia 'obter'. Isto
assume que o sv é um PVMG ou superior. Usar sv_len() ao invés.

U32 mg_comprimento(SV* sv)

mg_mágico
Ativa o status mágico de um SV. Veja "sv_magic".

void mg_magical(SV* sv)

mg_set Faça mágica após um valor ser atribuído ao SV. Veja "sv_magic".

int mg_set(SV*sv)

SvGETMAGIC
Invoca "mg_get" em um SV se tiver magia 'get'. Por exemplo, isso chamará
"FETCH" em uma variável vinculada. Esta macro avalia seu argumento mais de uma vez.

void SvGETMAGIC(SV* sv)

SvLOCK Organiza para que um bloqueio de exclusão mútua seja obtido em sv se um módulo adequado tiver
foi carregado.

void SvLOCK(SV* sv)

SvSETMAGIC
Invoca "mg_set" em um SV se tiver magia 'set'. Isso é necessário após
modificando um escalar, caso seja uma variável mágica como $| ou uma variável vinculada
(chama "LOJA"). Esta macro avalia seu argumento mais de uma vez.

void SvSETMAGIC(SV* sv)

SvSetMagicSV
Como "SvSetSV", mas faz qualquer mágica de conjunto necessária depois.

void SvSetMagicSV(SV* dsv, SV* ssv)

SvSetMagicSV_nosteal
Como "SvSetSV_nosteal", mas faz qualquer mágica de conjunto necessária depois.

void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)

SvSetSV Chama "sv_setsv" se dsv não for o mesmo que ssv. Pode avaliar argumentos mais do que
uma vez. Não lida com magia 'set' no SV de destino.

void SvSetSV(SV* dsv, SV* ssv)

SvSetSV_nosteal
Chama uma versão não destrutiva de "sv_setsv" se dsv não for o mesmo que ssv. Poderia
avaliar argumentos mais de uma vez.

void SvSetSV_nosteal(SV* dsv, SV* ssv)

SvSHARE Organiza para que sv seja compartilhado entre threads se um módulo adequado tiver sido carregado.

void SvSHARE(SV*sv)

SvUNLOCK
Libera um bloqueio de exclusão mútua em sv se um módulo adequado foi carregado.

void SvUNLOCK(SV* sv)

Memória Gestão de Sistemas

Copie a interface do gravador XSUB para a função C "memcpy". O "src" é a fonte,
"dest" é o destino, "nitems" é o número de itens e "type" é o
modelo. Pode falhar em cópias sobrepostas. Consulte também "Mover".

void Copy(void* src, void* dest, int nitens, type)

CopyD Como "Copiar", mas retorna dest. Útil para encorajar os compiladores a fazer chamadas finais
otimizar.

void * CopyD(void* src, void* dest, int nitens, type)

Mover a interface do gravador XSUB para a função C "memmove". O "src" é a fonte,
"dest" é o destino, "nitems" é o número de itens e "type" é o
modelo. Pode fazer movimentos sobrepostos. Consulte também "Copiar".

void Move(void* origem, void* dest, int nitens, tipo)

MoveD Como "Move", mas retorna dest. Útil para encorajar os compiladores a fazer chamadas finais
otimizar.

void * MoveD(void* origem, void* dest, int nitens, tipo)

Newx A interface do XSUB-writer para a função C "malloc".

A memória obtida por isso deve SOMENTE ser liberado com "Safefree".

Em 5.9.3, foi fundada a Newx () e amigos substituem os mais velhos Novo () API e descarta o primeiro
parâmetro, x, um auxílio de depuração que permitia que os chamadores se identificassem. Esta ajuda
foi substituído por uma nova opção de compilação, PERL_MEM_LOG (consulte "PERL_MEM_LOG" em
perlhacktips). A API mais antiga ainda está disponível para uso em módulos XS que suportam
perls mais velhos.

void Newx(void* ptr, int nitens, tipo)

Newxc A interface do XSUB-writer para a função C "malloc", com cast. Veja também
"Novo".

A memória obtida por isso deve SOMENTE ser liberado com "Safefree".

void Newxc(void* ptr, int nitens, type, cast)

Newxz A interface do gravador XSUB para a função C "malloc". A memória alocada é
zerado com "memzero". Veja também "Newx".

A memória obtida por isso deve SOMENTE ser liberado com "Safefree".

void Newxz(void* ptr, int nitens, tipo)

Veneno Veneno Com(0xEF) para capturar o acesso à memória liberada.

void Poison(void* dest, int nitens, type)

Sem veneno
Veneno Com(0xEF) para capturar o acesso à memória liberada.

void PoisonFree(void* dest, int nitens, type)

VenenoNovo
Veneno Com(0xAB) para capturar o acesso à memória alocada, mas não inicializada.

void PoisonNew(void* dest, int nitens, tipo)

Veneno Com
Encha a memória com um padrão de bytes (um byte repetido várias vezes) que
espero que capture tentativas de acessar a memória não inicializada.

void PoisonWith(void* dest, int nitens, tipo,
byte U8)

Renovar A interface do gravador XSUB para a função C "realloc".

A memória obtida por isso deve SOMENTE ser liberado com "Safefree".

void Renew(void* ptr, int nitens, tipo)

Renewc A interface do XSUB-writer para a função C "realloc", com cast.

A memória obtida por isso deve SOMENTE ser liberado com "Safefree".

void Renewc(void* ptr, int nitens, type, cast)

Seguro
A interface do gravador XSUB para a função C "livre".

Isso deve SOMENTE ser usado na memória obtida usando "Newx" e amigos.

vazio Safefree(void* ptr)

savepv Versão do Perl de "strdup()". Retorna um ponteiro para uma string recém-alocada que
é uma duplicata de "pv". O tamanho da string é determinado por "strlen()", que
significa que não pode conter caracteres "NUL" incorporados e deve ter um "NUL" à direita.
A memória alocada para a nova string pode ser liberada com o "Safefree()"
função.

Em algumas plataformas, Windows, por exemplo, toda a memória alocada pertencente a um thread é
desalocado quando esse segmento termina. Então, se você precisa que isso não aconteça, você precisa
use as funções de memória compartilhada, como "savessharedpv".

char* savepv(const char* pv)

A versão do savepvn Perl do que "strndup()" seria se existisse. Retorna um ponteiro para um
string recém-alocada que é uma duplicata dos primeiros bytes "len" de "pv",
mais um byte "NUL" à direita. A memória alocada para a nova string pode ser liberada
com a função "Safefree()".

Em algumas plataformas, Windows, por exemplo, toda a memória alocada pertencente a um thread é
desalocado quando esse segmento termina. Então, se você precisa que isso não aconteça, você precisa
use as funções de memória compartilhada, como "savessharedpvn".

char* savepvn(const char* pv, I32 len)

savepvs Como "savepvn", mas recebe uma string literal terminada em "NUL" em vez de uma
par string / comprimento.

char* savepvs(const char*s)

salvarcompartilhadopv
Uma versão de "savepv()" que aloca a string duplicada na memória que é
compartilhado entre os fios.

char* savesharedpv(const char* pv)

salvarcompartilhadopvn
Uma versão de "savepvn()" que aloca a string duplicada na memória que é
compartilhado entre os fios. (Com a diferença específica de que um ponteiro NULL não é
aceitável)

char* savesharedpvn(const char *const pv,
const STRLEN len)

salvarcompartilhadopvs
Uma versão de "savepvs()" que aloca a string duplicada na memória que é
compartilhado entre os fios.

char* savesharedpvs(const char* s)

savesharedsvpv
Uma versão de "savessharedpv()" que aloca a string duplicada na memória que
é compartilhado entre threads.

char* savesharedsvpv(SV *sv)

salvavpv
Uma versão de "savepv()"/"savepvn()" que obtém a string para duplicar do
passado em SV usando "SvPV()"

Em algumas plataformas, Windows, por exemplo, toda a memória alocada pertencente a um thread é
desalocado quando esse segmento termina. Então, se você precisa que isso não aconteça, você precisa
use as funções de memória compartilhada, como "savessharedsvpv".

char* salvavpv(SV*sv)

EstruturaCópia
Esta é uma macro independente de arquitetura para copiar uma estrutura para outra.

void StructCopy(tipo *src, tipo *dest, tipo)

Zero A interface do gravador XSUB para a função C "memzero". O "destino" é o
destino, "nitems" é o número de itens e "tipo" é o tipo.

void Zero(void* dest, int nitens, tipo)

ZeroD Como "Zero", mas retorna dest. Útil para encorajar os compiladores a fazer chamadas finais
otimizar.

void * ZeroD(void* dest, int nitens, tipo)

Gerais Funções

dump_c_backtrace
Despeja o backtrace C para o fp fornecido.

Retorna true se um backtrace puder ser recuperado, false se não.

bool dump_c_backtrace(PerlIO* fp, int max_profundidade,
salto int)

fbm_compile
Analisa a string para fazer buscas rápidas nela usando fbm_instr() -- a
Algoritmo de Boyer-Moore.

void fbm_compile(SV* sv, sinalizadores U32)

fbm_instr
Retorna a localização do SV na string delimitada por "big" e "bigend". Isto
retorna "NULL" se a string não puder ser encontrada. O "sv" não precisa ser
fbm_compiled, mas a busca não será tão rápida então.

char* fbm_instr(char unsigned* big,
caractere não assinado* bigend, SV* littlestr,
Sinalizadores U32)

foldEQ Retorna true se os bytes len iniciais das strings s1 e s2 são os mesmos case-
insensivelmente; falso caso contrário. Os bytes de intervalo ASCII maiúsculos e minúsculos correspondem
eles mesmos e seus homólogos opostos. Faixa sem caixa e sem ASCII
bytes correspondem apenas a si mesmos.

I32 foldEQ(const char* a, const char* b, I32 len)

foldEQ_locale
Retorna true se os bytes len iniciais das strings s1 e s2 forem os mesmos case-
insensivelmente na localidade atual; falso caso contrário.

I32 foldEQ_locale(const char* a, const char* b,
I32 Len)

form Toma um padrão de formato estilo sprintf e argumentos convencionais (não SV) e
retorna a string formatada.

(char *) Perl_form(pTHX_ const char* pat, ...)

pode ser usado em qualquer lugar onde uma string (char *) é necessária:

char * s = Perl_form("%d.%d",maior,menor);

Usa um único buffer privado, então se você quiser formatar várias strings, você deve
copie explicitamente as strings anteriores (e libere as cópias quando terminar).

char* formulário(const char* pat, ...)

getcwd_sv
Preencha o sv com o diretório de trabalho atual

int getcwd_sv(SV*sv)

get_c_backtrace_dump
Retorna um SV um dump de |profundidade| frames da pilha de chamadas, pulando o |skip|
os mais íntimos. profundidade de 20 geralmente é suficiente.

A saída anexada se parece com:

... 1 10e004812:0082 Perl_croak util.c:1716 / usr / bin / perl 2
10df8d6d2:1d72 perl_parse perl.c:3975 / usr / bin / perl ...

Os campos são separados por tabulação. A primeira coluna é a profundidade (sendo zero a
quadro não saltado mais interno). No hex:offset, o hex é onde o programa
contador estava em S_parse_body, e o :offset (pode estar faltando) diz quanto
dentro do S_parse_body estava o contador do programa.

O util.c:1716 é o arquivo de código-fonte e o número da linha.

A / usr / bin / perl é óbvio (espero).

Os desconhecidos são "-". Desconhecidos podem acontecer, infelizmente, com bastante facilidade: se a plataforma
não suporta a recuperação de informações; se o binário estiver faltando o debug
em formação; se o otimizador transformou o código, por exemplo, inlining.

SV* get_c_backtrace_dump(int max_profundidade, int pular)

ibcmp Este é um sinônimo para (! dobrarEQ())

I32 ibcmp(const char* a, const char* b, I32 len)

ibcmp_locale
Este é um sinônimo para (! foldEQ_locale())

I32 ibcmp_locale(const char* a, const char* b,
I32 Len)

is_safe_syscall
Teste se o "pv" fornecido não contém nenhum caractere "NUL" interno. Se isso
faz, defina "errno" como ENOENT, opcionalmente alerte e retorne FALSE.

Retorne TRUE se o nome for seguro.

Usado pelo IS_SAFE_SYSCALL() macro.

bool is_safe_syscall(const char *pv, STRLEN len,
const char *o que,
const char *op_name)

memEQ Teste dois buffers (que podem conter caracteres "NUL" incorporados, para ver se eles
igual. O parâmetro "len" indica o número de bytes a serem comparados. Devoluções
zero se igual, ou diferente de zero se não igual.

bool memEQ(char* s1, char* s2, STRLEN len)

memNE Teste dois buffers (que podem conter caracteres "NUL" incorporados, para ver se estão
não igual. O parâmetro "len" indica o número de bytes a serem comparados. Devoluções
zero se não for igual, ou diferente de zero se for igual.

bool memNE(char* s1, char* s2, STRLEN len)

mess Pegue um padrão de formato de estilo sprintf e uma lista de argumentos. Estes são usados ​​para gerar
uma mensagem de cadeia. Se a mensagem não terminar com uma nova linha, ela será
estendido com alguma indicação da localização atual no código, conforme descrito
para "mess_sv".

Normalmente, a mensagem resultante é retornada em um novo SV mortal. Durante global
destruição um único SV pode ser compartilhado entre os usos desta função.

SV * bagunça(const char *pat, ...)

mess_sv Expande uma mensagem, destinada ao usuário, para incluir uma indicação do atual
localização no código, se a mensagem ainda não parecer completa.

"basemsg" é a mensagem ou objeto inicial. Se for uma referência, será usado
como está e será o resultado desta função. Caso contrário, é usado como uma string,
e se já terminar com uma nova linha, é considerado completo, e o resultado
desta função será a mesma string. Se a mensagem não terminar com um
newline, então um segmento como "at foo.pl line 37" será anexado e possivelmente
outras cláusulas que indicam o estado atual de execução. A mensagem resultante
terminará com um ponto e uma nova linha.

Normalmente, a mensagem resultante é retornada em um novo SV mortal. Durante global
destruição um único SV pode ser compartilhado entre os usos desta função. Se "consumir"
for true, então a função tem permissão (mas não obrigatória) para modificar e retornar
"basemsg" em vez de alocar um novo SV.

SV * mess_sv(SV *basemsg, bool consumir)

meu_snprintf
A funcionalidade "snprintf" da biblioteca C, se disponível e compatível com os padrões (usa
"vsnprintf", na verdade). No entanto, se o "vsnprintf" não estiver disponível,
infelizmente use o inseguro "vsprintf" que pode ultrapassar o buffer (há um
verificação de superação, mas pode ser tarde demais). Considere usar "sv_vcatpvf" em vez disso, ou
obtendo "vsnprintf".

int my_snprintf(char *buffer, const Size_t len,
const char *formato, ...)

meu_sprintf
A biblioteca C "sprintf", encapsulada se necessário, para garantir que retornará o
comprimento da string gravada no buffer. Apenas raros sistemas pré-ANSI precisam do
função wrapper - geralmente esta é uma chamada direta para "sprintf".

int meu_sprintf(char *buffer, const char *pat, ...)

meu_strlcat
A biblioteca C "strlcat" se disponível, ou uma implementação Perl dela. Isto
opera em strings terminadas em C "NUL".

"my_strlcat()" acrescenta a string "src" ao final de "dst". Ele vai anexar no máximo
"size - strlen(dst) - 1" caracteres. Ele então terminará com "NUL", a menos que "size"
é 0 ou a string "dst" original era maior que "size" (na prática, isso deve
não acontece, pois significa que "tamanho" está incorreto ou que "dst" não é um
string terminada com "NUL" apropriada).

Observe que "size" é o tamanho total do buffer de destino e o resultado é
garantido para ser "NUL"-terminado se houver espaço. Observe que espaço para o "NUL"
deve ser incluído em "tamanho".

Tamanho_t my_strlcat(char *dst, const char *src,
Tamanho_t tamanho)

meu_strlcpy
A biblioteca C "strlcpy" se disponível, ou uma implementação Perl dela. Isto
opera em strings terminadas em C "NUL".

"my_strlcpy()" copia até "size - 1" caracteres da string "src" para "dst",
"NUL"-terminando o resultado se "size" não for 0.

Tamanho_t my_strlcpy(char *dst, const char *src,
Tamanho_t tamanho)

meu_vsnprintf
A biblioteca C "vsnprintf" se disponível e compatível com os padrões. No entanto, se se
o "vsnprintf" não está disponível, infelizmente usará o inseguro "vsprintf"
que pode sobrecarregar o buffer (há uma verificação de saturação, mas isso pode ser muito
atrasado). Considere usar "sv_vcatpvf" ou obter "vsnprintf".

int my_vsnprintf(char *buffer, const Size_t len,
const char *formato, va_list ap)

PERL_SYS_INIT
Fornece ajuste específico do sistema do ambiente de tempo de execução C necessário para executar
Intérpretes Perl. Isso deve ser chamado apenas uma vez, antes de criar qualquer Perl
intérpretes.

vazio PERL_SYS_INIT(int *argc, char*** argv)

PERL_SYS_INIT3
Fornece ajuste específico do sistema do ambiente de tempo de execução C necessário para executar
Intérpretes Perl. Isso deve ser chamado apenas uma vez, antes de criar qualquer Perl
intérpretes.

void PERL_SYS_INIT3(int *argc, char*** argv,
char*** ambiente)

PERL_SYS_TERM
Fornece limpeza específica do sistema do ambiente de tempo de execução C após executar o Perl
intérpretes. Isso deve ser chamado apenas uma vez, após liberar qualquer Perl restante
intérpretes.

vazio PERL_SYS_TERM()

quadmath_format_needed
quadmath_format_needed() retorna true se a string de formato parece conter em
menos um especificador de formato %[efgaEFGA] sem prefixo Q, ou retorna false caso contrário.

A detecção do especificador de formato não é uma detecção de sintaxe de impressão completa, mas
deve pegar os casos mais comuns.

Se true for retornado, esses argumentos rede de apoio social teoricamente ser processado com
quadmath_snprintf(), mas caso haja mais de um especificador de formato (consulte
"quadmath_format_single"), e se houver mais alguma coisa além desse (mesmo
apenas um único byte), eles não podes ser processado porque quadmath_snprintf() é muito
estrito, aceitando apenas uma especificação de formato e nada mais. Neste caso, o código
provavelmente deve falhar.

bool quadmath_format_needed(const char * formato)

quadmath_format_single
quadmath_snprintf() é muito rigoroso sobre sua string de formato e falhará,
retornando -1, se o formato for inválido. Aceita exatamente uma especificação de formato.

quadmath_format_single() verifica se a especificação única pretendida parece sã: começa
com "%", tem apenas um "%", termina com "[efgaEFGA]" e tem "Q" antes dele. Isto
não é uma "verificação de sintaxe printf" completa, apenas o básico.

Retorna o formato se for válido, NULL se não for.

quadmath_format_single() pode e irá corrigir o "Q" ausente, se
necessário. Neste caso devolverá a cópia modificada do formato, qual da
chamador precisarão necessidade para livre.

Veja também "quadmath_format_needed".

const char* quadmath_format_single(const char* formato)

READ_XDIGIT
Retorna o valor de um dígito hexadecimal de intervalo ASCII e avança o ponteiro de string.
O comportamento só é bem definido quando isXDIGIT(*str) é verdadeiro.

U8 READ_XDIGIT(caracterestr*)

strEQ Teste duas strings para ver se são iguais. Retorna verdadeiro ou falso.

bool strEQ(char* s1, char* s2)

strGE Teste duas strings para ver se a primeira, "s1", é maior ou igual à
segundo, "s2". Retorna verdadeiro ou falso.

bool string(char* s1, char* s2)

strGT Teste duas strings para ver se a primeira, "s1", é maior que a segunda, "s2".
Retorna verdadeiro ou falso.

bool strGT(char* s1, char* s2)

strLE Teste duas strings para ver se a primeira, "s1", é menor ou igual à segunda,
"s2". Retorna verdadeiro ou falso.

bool strLE(char* s1, char* s2)

strLT Teste duas strings para ver se a primeira, "s1", é menor que a segunda, "s2".
Retorna verdadeiro ou falso.

bool strLT(char* s1, char* s2)

strNE Teste duas strings para ver se são diferentes. Retorna verdadeiro ou falso.

bool string(char* s1, char* s2)

strnEQ Teste duas strings para ver se elas são iguais. O parâmetro "len" indica a
número de bytes para comparar. Retorna verdadeiro ou falso. (Um wrapper para "strncmp").

bool strnEQ(char* s1, char* s2, STRLEN len)

strnNE Teste duas strings para ver se são diferentes. O parâmetro "len" indica a
número de bytes para comparar. Retorna verdadeiro ou falso. (Um wrapper para "strncmp").

bool strnNE(char* s1, char* s2, STRLEN len)

sv_destruível
Rotina fictícia que informa que o objeto pode ser destruído quando não há compartilhamento
módulo presente. Ele ignora seu único argumento SV e retorna 'true'. Existe para
evite testar um ponteiro de função NULL e porque ele poderia avisar sob
algum nível de rigor.

bool sv_destruível(SV *sv)

sv_nosharing
Rotina fictícia que "compartilha" um SV quando não há módulo de compartilhamento presente. Ou
"bloqueia" isso. Ou "desbloqueia". Em outras palavras, ignora seu único argumento SV.
Existe para evitar o teste de um ponteiro de função NULL e porque poderia potencialmente
advertir sob algum nível de rigor.

void sv_nosharing(SV *sv)

vmess "pat" e "args" são um padrão de formato no estilo sprintf e um argumento encapsulado
Lista. Estes são usados ​​para gerar uma mensagem de string. Se a mensagem não terminar
com uma nova linha, então ele será estendido com alguma indicação do atual
localização no código, conforme descrito para "mess_sv".

Normalmente, a mensagem resultante é retornada em um novo SV mortal. Durante global
destruição um único SV pode ser compartilhado entre os usos desta função.

SV * vmess(const char *pat, va_list *args)

MRO Funções

Essas funções estão relacionadas à ordem de resolução de métodos de classes perl

mro_get_linear_isa
Retorna a linearização mro para o stash fornecido. Por padrão, isso será
o que quer que "mro_get_linear_isa_dfs" retorne, a menos que algum outro MRO esteja em vigor para
o esconderijo. O valor de retorno é um AV* somente leitura.

Você é responsável por "SvREFCNT_inc()" no valor de retorno se planeja armazenar
em qualquer lugar semi-permanentemente (caso contrário, pode ser excluído de você o
próxima vez que o cache for invalidado).

AV* mro_get_linear_isa(HV* estoque)

mro_method_changed_in
Invalida o cache de método em qualquer classe filha do stash fornecido, para que eles
pode notar as mudanças neste.

Idealmente, todas as instâncias de "PL_sub_generation++" na fonte perl fora do mro.c
deve ser substituído por chamadas para isso.

Perl lida automaticamente com a maioria das maneiras comuns que um método pode ser redefinido.
No entanto, existem algumas maneiras de alterar um método em um stash sem o
aviso de código de cache, nesse caso você precisa chamar esse método depois:

1) Manipulando diretamente as entradas stash HV do código XS.

2) Atribuir uma referência a uma constante escalar readonly em uma entrada stash para
para criar uma sub-rotina constante (como faz constant.pm).

Este mesmo método está disponível a partir de perl puro via,
"mro::method_changed_in(classname)".

void mro_method_changed_in(HV* esconderijo)

mro_register
Registra um plugin mro personalizado. Veja perlmroapi para detalhes.

void mro_register(const estrutura mro_alg *mro)

Multichamada Funções

dMULTICAL
Declare variáveis ​​locais para uma chamada múltipla. Veja "LIGHTWEIGHT CALBACKS" em perlcall.

dMULTICAL;

MÚLTIPLO
Faça um retorno de chamada leve. Veja "LIGHTWEIGHT CALBACKS" em perlcall.

MÚLTIPLO;

POP_MULTICAL
Colchete de fechamento para um retorno de chamada leve. Consulte "CHAMADA LEVE" em
perlcall.

POP_MULTICAL;

PUSH_MULTICAL
Suporte de abertura para um retorno de chamada leve. Consulte "CHAMADA LEVE" em
perlcall.

PUSH_MULTICAL;

Numérico funções

grok_bin
converte uma string representando um número binário em formato numérico.

Na entrada começo e * len dê a string para digitalizar, *bandeiras dá sinalizadores de conversão,
e resultar deve ser NULL ou um ponteiro para um NV. A varredura para no final do
string ou o primeiro caractere inválido. A menos que "PERL_SCAN_SILENT_ILLDIGIT" esteja definido
in *bandeiras, encontrar um caractere inválido também acionará um aviso. Sobre
retorno * len é definido para o comprimento da string digitalizada e *bandeiras dá saída
bandeiras.

Se o valor for <= "UV_MAX", ele é retornado como UV, os sinalizadores de saída são limpos,
e nada está escrito para *resultado. Se o valor for > UV_MAX "grok_bin" retorna
UV_MAX, define "PERL_SCAN_GREATER_THAN_UV_MAX" nos sinalizadores de saída e grava o
valor para *resultado (ou o valor é descartado se resultar é nulo).

O número binário pode opcionalmente ser prefixado com "0b" ou "b", a menos que
"PERL_SCAN_DISALLOW_PREFIX" é definido em *bandeiras na entrada. Se
"PERL_SCAN_ALLOW_UNDERSCORES" é definido em *bandeiras então o número binário pode usar '_'
caracteres para separar os dígitos.

UV grok_bin(const char* início, STRLEN* len_p,
Sinalizadores I32*, NV *resultado)

grok_hex
converte uma string representando um número hexadecimal em formato numérico.

Na entrada começo e *len_p dê a string para digitalizar, *bandeiras dá sinalizadores de conversão,
e resultar deve ser NULL ou um ponteiro para um NV. A varredura para no final do
string ou o primeiro caractere inválido. A menos que "PERL_SCAN_SILENT_ILLDIGIT" esteja definido
in *bandeiras, encontrar um caractere inválido também acionará um aviso. Sobre
retorno * len é definido para o comprimento da string digitalizada e *bandeiras dá saída
bandeiras.

Se o valor for <= UV_MAX, ele é retornado como um UV, os sinalizadores de saída são limpos e
nada está escrito para *resultado. Se o valor for > UV_MAX "grok_hex" retorna
UV_MAX, define "PERL_SCAN_GREATER_THAN_UV_MAX" nos sinalizadores de saída e grava o
valor para *resultado (ou o valor é descartado se resultar é nulo).

O número hexadecimal pode opcionalmente ser prefixado com "0x" ou "x", a menos que
"PERL_SCAN_DISALLOW_PREFIX" é definido em *bandeiras na entrada. Se
"PERL_SCAN_ALLOW_UNDERSCORES" é definido em *bandeiras então o número hexadecimal pode usar '_'
caracteres para separar os dígitos.

UV grok_hex(const char* início, STRLEN* len_p,
Sinalizadores I32*, NV *resultado)

grok_infnan
Ajudante para número_grok(), aceita várias formas de soletrar "infinito" ou "não é um
number" e retorna uma das seguintes combinações de sinalizadores:

IS_NUMBER_INFINITE
IS_NUMBER_NAN
IS_NUMBER_INFINITE | IS_NUMBER_NEG
IS_NUMBER_NAN | IS_NUMBER_NEG
0

possivelmente |-ed com IS_NUMBER_TRAILING.

Se um infinito ou um não-número for reconhecido, o *sp apontará para um byte
além do final da string reconhecida. Se o reconhecimento falhar, zero é
retornado e o *sp não se moverá.

int grok_infnan(const char** sp, const char *enviar)

número_grok
Idêntico a grok_number_flags() com sinalizadores zerados.

int número_grok(const char *pv, STRLEN len,
UV *valorp)

grok_number_flags
Reconhecer (ou não) um número. O tipo do número é retornado (0 se
não reconhecido), caso contrário, é uma combinação de bit OR de IS_NUMBER_IN_UV,
IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT, IS_NUMBER_NEG,
IS_NUMBER_INFINITY, IS_NUMBER_NAN (definido em perl.h).

Se o valor do número couber em um UV, ele é retornado no *valuep
IS_NUMBER_IN_UV será definido para indicar que *valuep é válido, IS_NUMBER_IN_UV
nunca será definido a menos que *valuep seja válido, mas *valuep pode ter sido atribuído a
durante o processamento, embora IS_NUMBER_IN_UV não esteja definido no retorno. Se valorp é
NULL, IS_NUMBER_IN_UV será definido para os mesmos casos de quando valuep não for NULL,
mas nenhuma atribuição real (ou SEGV) ocorrerá.

IS_NUMBER_NOT_INT será definido com IS_NUMBER_IN_UV se decimais à direita forem vistos
(nesse caso *valuep fornece o valor verdadeiro truncado para um inteiro), e
IS_NUMBER_NEG se o número for negativo (nesse caso *valuep contém o valor absoluto
valor). IS_NUMBER_IN_UV não está definido se a notação e foi usada ou o número é maior
do que um UV.

"flags" permite apenas "PERL_SCAN_TRAILING", que permite trilhas não numéricas
texto sobre um sucesso de outra forma grok, definindo "IS_NUMBER_TRAILING" no resultado.

int grok_number_flags(const char *pv, STRLEN len,
UV *valorp, sinalizadores U32)

grok_numeric_radix
Digitalize e pule para um separador decimal numérico (raiz).

bool grok_numeric_radix(const char **sp,
const char * enviar)

grok_out
converte uma string representando um número octal em formato numérico.

Na entrada começo e * len dê a string para digitalizar, *bandeiras dá sinalizadores de conversão,
e resultar deve ser NULL ou um ponteiro para um NV. A varredura para no final do
string ou o primeiro caractere inválido. A menos que "PERL_SCAN_SILENT_ILLDIGIT" esteja definido
in *bandeiras, encontrar um 8 ou 9 também acionará um aviso. No retorno * len is
definido para o comprimento da string digitalizada e *bandeiras fornece sinalizadores de saída.

Se o valor for <= UV_MAX, ele é retornado como um UV, os sinalizadores de saída são limpos e
nada está escrito para *resultado. Se o valor for > UV_MAX "grok_oct" retorna
UV_MAX, define "PERL_SCAN_GREATER_THAN_UV_MAX" nos sinalizadores de saída e grava o
valor para *resultado (ou o valor é descartado se resultar é nulo).

Se "PERL_SCAN_ALLOW_UNDERSCORES" estiver definido em *bandeiras então o número octal pode usar
Caracteres '_' para separar dígitos.

UV grok_oct(const char* início, STRLEN* len_p,
Sinalizadores I32*, NV *resultado)

isinfnan
Perl_isinfnan() é uma função utilitária que retorna true se o argumento NV for
um infinito ou um NaN, caso contrário falso. Para testar com mais detalhes, use Perl_isinf()
e Perl_isnan().

Este também é o inverso lógico de Perl_isfinite().

bool isinfnan(NV nv)

Perl_signbit
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Retorna um inteiro diferente de zero se o bit de sinal em um NV estiver definido e 0 se não estiver.

Se o Configure detectar que este sistema tem um bit de sinal() que funcionará com nossos NVs, então
nós apenas o usamos através do #define em perl.h. Caso contrário, recorra a este
implementação. O principal uso desta função é capturar -0.0.

Configurar notas: Esta função é chamada de 'Perl_signbit' em vez de um simples
'signbit' porque é fácil imaginar um sistema com um bit de sinal() função ou
macro que não funciona com nossa escolha particular de NVs. Nós não devemos
apenas re-#defina signbit como Perl_signbit e espere que os cabeçalhos padrão do sistema
seja feliz. Além disso, esta é uma função sem contexto (sem pTHX_) porque Perl_signbit()
geralmente é re-#definido em perl.h como uma simples chamada de macro para o sistema bit de sinal().
Os usuários devem sempre ligar Perl_signbit().

int Perl_signbit(NV f)

scan_bin
Para compatibilidade com versões anteriores. Use "grok_bin" em vez disso.

NV scan_bin(const char* início, STRLEN len,
STRLEN* relen)

scan_hex
Para compatibilidade com versões anteriores. Use "grok_hex" em vez disso.

NV scan_hex(const char* início, STRLEN len,
STRLEN* relen)

scan_out
Para compatibilidade com versões anteriores. Use "grok_oct" em vez disso.

NV scan_oct(const char* início, STRLEN len,
STRLEN* relen)

Obsoleto para trás compatibilidade funções

Alguns deles também estão obsoletos. Você pode excluí-los do seu Perl compilado por
adicionando esta opção para Configurar: "-Accflags='-DNO_MATHOMS'"

custom_op_desc
Retorna a descrição de uma determinada operação personalizada. Isso já foi usado pelo OP_DESC
macro, mas não é mais: foi mantido apenas para compatibilidade e não deve
ser usado.

const char * custom_op_desc(const OP *o)

nome_op_personalizado
Retorna o nome de uma determinada operação personalizada. Isso já foi usado pela macro OP_NAME,
mas não é mais: foi mantido apenas para compatibilidade e não deve ser usado.

const char * custom_op_name(const OP *o)

gv_fetchmethod
Consulte "gv_fetchmethod_autoload".

GV* gv_fetchmethod(HV* stash, const char* nome)

is_utf8_char
DESCONTINUADA! É planejado remover esta função de uma versão futura do Perl.
Não o use para novo código; remova-o do código existente.

Testa se algum número arbitrário de bytes começa em um caractere UTF-8 válido. Observação
que um caractere INVARIANT (ou seja, ASCII em máquinas não EBCDIC) é um UTF-8 válido
personagem. O número real de bytes no caractere UTF-8 será retornado se
é válido, caso contrário 0.

Esta função está obsoleta devido à possibilidade de que uma entrada malformada possa
causar leitura além do final do buffer de entrada. Use "isUTF8_CHAR" em vez disso.

STRLEN is_utf8_char(const U8 *s)

is_utf8_char_buf
Isso é idêntico à macro "isUTF8_CHAR".

STRLEN is_utf8_char_buf(const U8 *buf,
const U8 *buf_end)

pacote_cat
O motor que implementa pacote() Função Perl. Nota: os parâmetros next_in_list e
bandeiras não são usadas. Esta chamada não deve ser usada; use a lista de pacotes em vez disso.

void pack_cat(SV *cat, const char *pat,
const char *patend, SV **beglist,
SV **lista final, SV ***next_in_list,
Sinalizadores U32)

pad_compname_type
Procura o tipo da variável léxica na posição po no atual-
bloco de compilação. Se a variável for digitada, o stash da classe para a qual ela é
digitado é retornado. Caso contrário, "NULL" é retornado.

HV * pad_compname_type(PADOFFSET po)

sv_2pvbyte_nolen
Retorne um ponteiro para a representação codificada em byte do SV. Pode causar o SV
para ser rebaixado de UTF-8 como um efeito colateral.

Geralmente acessado através da macro "SvPVbyte_nolen".

char* sv_2pvbyte_nolen(SV* sv)

sv_2pvutf8_nolen
Retorne um ponteiro para a representação codificada em UTF-8 do SV. Pode causar o SV
para ser atualizado para UTF-8 como um efeito colateral.

Geralmente acessado através da macro "SvPVutf8_nolen".

char* sv_2pvutf8_nolen(SV* sv)

sv_2pv_nolen
Como "sv_2pv()", mas não retorna o comprimento também. Normalmente você deve usar o
macro wrapper "SvPV_nolen(sv)" em vez disso.

char* sv_2pv_nolen(SV* sv)

sv_catpvn_mg
Como "sv_catpvn", mas também lida com magia 'set'.

void sv_catpvn_mg(SV *sv, const char *ptr,
STRLEN Len)

sv_catsv_mg
Como "sv_catsv", mas também lida com a magia 'set'.

vazio sv_catsv_mg(SV *dsv, SV *ssv)

sv_force_normal
Desfaça vários tipos de falsificação em um SV: se o PV for uma string compartilhada, faça um
cópia privada; se formos ref, pare de refing; se formos um glob, faça o downgrade para um xpvmg.
Veja também "sv_force_normal_flags".

vazio sv_force_normal(SV *sv)

sv_iv Uma implementação privada da macro "SvIVx" para compiladores que não podem lidar com
expressões macro complexas. Sempre use a macro em vez disso.

IV sv_iv(SV* sv)

sv_nolocking
Rotina fictícia que "bloqueia" um SV quando não há módulo de bloqueio presente. Existe
para evitar o teste de um ponteiro de função NULL e porque poderia avisar
sob algum nível de rigor.

"Substituída por sv_nosharing().

vazio sv_nolocking(SV *sv)

sv_nounlocking
Rotina fictícia que "desbloqueia" um SV quando não há nenhum módulo de bloqueio presente.
Existe para evitar o teste de um ponteiro de função NULL e porque poderia potencialmente
advertir sob algum nível de rigor.

"Substituída por sv_nosharing().

void sv_nounlocking(SV *sv)

sv_nv Uma implementação privada da macro "SvNVx" para compiladores que não podem lidar com
expressões macro complexas. Sempre use a macro em vez disso.

NV sv_nv(SV* sv)

sv_pv Use a macro "SvPV_nolen" em vez disso

char* sv_pv(SV *sv)

sv_pvbyte
Use "SvPVbyte_nolen" em vez disso.

char* sv_pvbyte(SV *sv)

sv_pvbyten
Uma implementação privada da macro "SvPVbyte" para compiladores que não podem lidar
com expressões macro complexas. Sempre use a macro em vez disso.

char* sv_pvbyten(SV *sv, STRLEN *lp)

sv_pvn Uma implementação privada da macro "SvPV" para compiladores que não podem lidar com
expressões macro complexas. Sempre use a macro em vez disso.

char* sv_pvn(SV *sv, STRLEN *lp)

sv_pvutf8
Use a macro "SvPVutf8_nolen" em vez disso

char* sv_pvutf8(SV *sv)

sv_pvutf8n
Uma implementação privada da macro "SvPVutf8" para compiladores que não conseguem lidar
com expressões macro complexas. Sempre use a macro em vez disso.

char* sv_pvutf8n(SV *sv, STRLEN *lp)

sv_taint
Contaminar um SV. Use "SvTAINTED_on" em vez disso.

vazio sv_taint(SV* sv)

sv_unref
Desativa o status de RV do SV e diminui a contagem de referência de tudo o que foi
sendo referenciado pelo RV. Isso quase pode ser pensado como uma inversão de
"novoSVrv". Este é "sv_unref_flags" com o "flag" sendo zero. Consulte "SvROK_off".

void sv_unref(SV*sv)

sv_usepvn
Diz a um SV para usar "ptr" para encontrar seu valor de string. Implementado chamando
"sv_usepvn_flags" com "flags" de 0, portanto, não lida com magia 'set'. Ver
"sv_usepvn_flags".

void sv_usepvn(SV* sv, char* ptr, STRLEN len)

sv_usepvn_mg
Como "sv_usepvn", mas também lida com a magia 'set'.

void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)

sv_uv Uma implementação privada da macro "SvUVx" para compiladores que não podem lidar com
expressões macro complexas. Sempre use a macro em vez disso.

UV sv_uv(SV* sv)

descompactar_str
O motor que implementa desempacotar () Função Perl. Nota: parâmetros strbeg, new_s
e ocnt não são usados. Esta chamada não deve ser usada, use unpackstring em vez disso.

I32 unpack_str(const char *pat, const char *patend,
const char *s, const char *strbeg,
const char *trend, char **new_s,
I32 ocnt, sinalizadores U32)

utf8_to_uvchr
DESCONTINUADA! É planejado remover esta função de uma versão futura do Perl.
Não o use para novo código; remova-o do código existente.

Retorna o ponto de código nativo do primeiro caractere na string "s" que é
supõe-se que esteja na codificação UTF-8; "retlen" será definido para o comprimento, em bytes, de
aquele personagem.

Algumas, mas não todas, malformações UTF-8 são detectadas e, de fato, algumas malformadas
entrada pode causar leitura além do final do buffer de entrada, e é por isso que isso
função está obsoleta. Use "utf8_to_uvchr_buf" em vez disso.

Se "s" apontar para uma das malformações detectadas e os avisos UTF8 estiverem ativados,
zero é retornado e *retlen é definido (se "retlen" não for NULL) para -1. Se aqueles
avisos estão desativados, o valor calculado se estiver bem definido (ou o Unicode REPLACEMENT
CHARACTER, se não) é retornado silenciosamente e *retlen é definido (se "retlen" não for
NULL) para que ("s" + *retlen) seja a próxima posição possível em "s" que poderia
iniciar um caractere não malformado. Veja "utf8n_to_uvchr" para detalhes sobre quando o
O CARACTER DE SUBSTITUIÇÃO é devolvido.

UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)

utf8_to_uvuni
DESCONTINUADA! É planejado remover esta função de uma versão futura do Perl.
Não o use para novo código; remova-o do código existente.

Retorna o ponto de código Unicode do primeiro caractere na string "s" que é
supõe-se que esteja na codificação UTF-8; "retlen" será definido para o comprimento, em bytes, de
aquele personagem.

Algumas, mas não todas, malformações UTF-8 são detectadas e, de fato, algumas malformadas
entrada pode causar leitura além do final do buffer de entrada, que é uma das razões
por que esta função está obsoleta. A outra é que apenas em casos extremamente limitados
circunstâncias, caso o ponto de código Unicode versus código nativo seja de algum interesse para
vocês. Veja "utf8_to_uvuni_buf" para alternativas.

Se "s" apontar para uma das malformações detectadas e os avisos UTF8 estiverem ativados,
zero é retornado e *retlen é definido (se "retlen" não apontar para NULL) como -1. Se
esses avisos estão desativados, o valor calculado se estiver bem definido (ou o Unicode
CARACTER DE SUBSTITUIÇÃO, se não) é retornado silenciosamente e *retlen é definido (se
"retlen" não é NULL) para que ("s" + *retlen) seja a próxima posição possível em "s"
que poderia iniciar um caractere não malformado. Veja "utf8n_to_uvchr" para detalhes sobre
quando o CARACTER DE SUBSTITUIÇÃO é retornado.

UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)

Optree formação

novoASSIGNOP
Constrói, verifica e retorna uma atribuição op. esquerda e certo fornecer o
parâmetros da atribuição; são consumidos por esta função e passam a fazer parte
da árvore op construída.

If tipo de opção for "OP_ANDASSIGN", "OP_ORASSIGN" ou "OP_DORASSIGN", então um
opttree condicional é construído. Se tipo de opção é o opcode de um operador binário,
como "OP_BIT_OR", então é construído um op que executa a operação binária
e atribui o resultado ao argumento esquerdo. De qualquer forma, se tipo de opção é diferente de zero
então bandeiras não tem efeito.

If tipo de opção é zero, então uma atribuição escalar ou de lista simples é construída. Que
tipo de atribuição é determinado automaticamente. bandeiras dá os oito bits
de "op_flags", exceto que "OPf_KIDS" será definido automaticamente e, deslocado para cima
oito bits, os oito bits de "op_private", exceto que o bit com valor 1 ou 2
é definido automaticamente conforme necessário.

OP * newASSIGNOP(i32 sinalizadores, OP *esquerda, I32 tipo de opção,
OP *direita)

novoBINOP
Constrói, verifica e retorna um op de qualquer tipo binário. tipo é o código de operação.
bandeiras fornece os oito bits de "op_flags", exceto que "OPf_KIDS" será definido
automaticamente, e, deslocados oito bits para cima, os oito bits de "op_private", exceto
que o bit com valor 1 ou 2 é definido automaticamente conforme necessário. primeiro e último
forneça até dois ops para serem os filhos diretos do op binário; eles são consumidos
por esta função e se tornar parte da árvore op construída.

OP * newBINOP(tipo I32, sinalizadores I32, OP *primeiro,
OP *último)

novoCONDOP
Constrói, verifica e retorna uma expressão condicional ("cond_expr") op. bandeiras
fornece os oito bits de "op_flags", exceto que "OPf_KIDS" será definido
automaticamente, e, deslocados oito bits para cima, os oito bits de "op_private", exceto
que o bit com valor 1 é definido automaticamente. primeiro fornece a expressão
selecionar entre os dois ramos, e trueop e falsoop abastecer as filiais;
eles são consumidos por essa função e se tornam parte da árvore op construída.

OP * newCONDOP(sinalizadores I32, OP *first, OP *trueop,
OP *falseop)

novoDEFSVOP
Constrói e retorna um op para acessar $_, seja como uma variável léxica (se
declarado como "my $_") no escopo atual ou o $_ global.

OP * novoDEFSVOP()

novoFOROP
Constrói, verifica e retorna uma árvore op expressando um loop "foreach" (iteração
através de uma lista de valores). Trata-se de um loop pesado, com estrutura que permite
saindo do loop por "last" e afins.

sv opcionalmente fornece a variável que será alias para cada item por vez; E se
null, o padrão é $_ (seja léxico ou global). expr fornece a lista de
valores para iterar. quadra fornece o corpo principal do loop, e conta
opcionalmente fornece um bloco "continuar" que funciona como uma segunda metade do corpo.
Todas essas entradas de optree são consumidas por esta função e passam a fazer parte do
árvore op construída.

bandeiras dá os oito bits de "op_flags" para o "leaveloop" e, deslocado para cima
oito bits, os oito bits de "op_private" para o op "leaveloop", exceto que (em
ambos os casos) alguns bits serão definidos automaticamente.

OP * newFOROP(sinalizadores I32, OP *sv, OP *expr, OP *block,
OP *cont.)

novoGIVENOP
Constrói, verifica e retorna uma árvore op expressando um bloco "dado". cond
fornece a expressão que será atribuída localmente a uma variável léxica, e
quadra fornece o corpo do construto "dado"; eles são consumidos por isso
funcionar e se tornar parte da árvore op construída. defsv_off é o deslocamento do pad
da variável léxica escalar que será afetada. Se for 0, o $_ global
será usada.

OP * novoGIVENOP(OP *cond, OP *bloco,
PADOOFFSET defsv_off)

newGVOP Constrói, verifica e retorna um op de qualquer tipo que envolva um
referência a um GV. tipo é o código de operação. bandeiras dá os oito bits de "op_flags".
gv identifica o GV que o op deve referenciar; chamar esta função não
transferir a propriedade de qualquer referência a ele.

OP * newGVOP(tipo I32, sinalizadores I32, GV *gv)

novoLISTOP
Constrói, verifica e retorna um op de qualquer tipo de lista. tipo é o código de operação.
bandeiras fornece os oito bits de "op_flags", exceto que "OPf_KIDS" será definido
automaticamente se necessário. primeiro e último fornecer até duas operações para ser direto
filhos da lista op; são consumidos por esta função e passam a fazer parte do
árvore op construída.

Para a maioria dos operadores de lista, a função de verificação espera que todas as operações infantis estejam presentes
já, então chamar "newLISTOP(OP_JOIN, ...)" (por exemplo) não é apropriado. O que você
quero fazer nesse caso é criar um op do tipo OP_LIST, anexar mais filhos a
e, em seguida, chame "op_convert_list". Consulte "op_convert_list" para obter mais informações.

OP * novoLISTOP(tipo I32, sinalizadores I32, OP *primeiro,
OP *último)

novoLOGOP
Constrói, verifica e retorna uma operação lógica (controle de fluxo). tipo é o código de operação.
bandeiras fornece os oito bits de "op_flags", exceto que "OPf_KIDS" será definido
automaticamente, e, deslocados oito bits para cima, os oito bits de "op_private", exceto
que o bit com valor 1 é definido automaticamente. primeiro fornece a expressão
controlar o fluxo e de outros fornece a cadeia lateral (alternativa) de operações; elas
são consumidos por esta função e tornam-se parte da árvore op construída.

OP * newLOGOP(tipo I32, sinalizadores I32, OP *primeiro,
OP *outro)

novoLOOPEX
Constrói, verifica e retorna uma operação de saída de loop (como "goto" ou "last").
tipo é o código de operação. rótulo fornece o parâmetro que determina o alvo da
op; ele é consumido por esta função e se torna parte da árvore op construída.

OP * novoLOOPEX(tipo I32, OP *rótulo)

novoLOOPOP
Constrói, verifica e retorna uma árvore op expressando um loop. Este é apenas um loop
no fluxo de controle através da árvore op; não tem o loop pesado
estrutura que permite sair do loop por "last" e afins. bandeiras dá
oito bits de "op_flags" para o op de nível superior, exceto que alguns bits serão definidos
automaticamente conforme necessário. expr fornece o loop de controle de expressão
iteração, e quadra fornece o corpo do loop; eles são consumidos por isso
funcionar e se tornar parte da árvore op construída. depurável é atualmente
não utilizado e deve ser sempre 1.

OP * newLOOPOP(sinalizadores I32, I32 depurável, OP *expr,
OP *bloco)

novoMETHOP
Constrói, verifica e retorna um op do tipo de método com um nome de método avaliado
em tempo de execução. tipo é o código de operação. bandeiras fornece os oito bits de "op_flags", exceto
que "OPf_KIDS" será definido automaticamente e, deslocados oito bits para cima, os oito
bits de "op_private", exceto que o bit com valor 1 é definido automaticamente.
Dynamic_meth fornece um op que avalia o nome do método; é consumido por isso
funcionar e se tornar parte da árvore op construída. Optypes suportados:
OP_METHOD.

OP * newMETHOP(tipo I32, sinalizadores I32, OP *primeiro)

novoMETHOP_named
Constrói, verifica e retorna um op do tipo de método com um nome de método constante.
tipo é o código de operação. bandeiras dá os oito bits de "op_flags", e, deslocado para cima
oito bits, os oito bits de "op_private". const_meth fornece um método constante
nome; deve ser uma string COW compartilhada. Optypes suportados: OP_METHOD_NAMED.

OP * newMETHOP_named(tipo I32, sinalizadores I32,
SV *const_meth)

novoNULLLIST
Constrói, verifica e retorna um novo op "stub", que representa uma lista vazia
expressão.

OP * novoNULLLIST()

newOP Constrói, verifica e retorna um op de qualquer tipo base (qualquer tipo que não tenha
Campos). tipo é o código de operação. bandeiras dá os oito bits de "op_flags", e,
deslocou oito bits, os oito bits de "op_private".

OP * newOP(tipo I32, sinalizadores I32)

novoPADOP
Constrói, verifica e retorna um op de qualquer tipo que envolva uma referência a um
elemento almofada. tipo é o código de operação. bandeiras dá os oito bits de "op_flags". UMA
slot de pad é alocado automaticamente e é preenchido com sv; esta função leva
propriedade de uma referência a ele.

Esta função só existe se Perl foi compilado para usar threads.

OP * newPADOP(tipo I32, sinalizadores I32, SV *sv)

newPMOP Constrói, verifica e retorna um op de qualquer tipo de correspondência de padrão. tipo é o
Código de operação. bandeiras dá os oito bits de "op_flags" e, deslocados oito bits, o
oito bits de "op_private".

OP * newPMOP(tipo I32, sinalizadores I32)

newPVOP Constrói, verifica e retorna um op de qualquer tipo que envolva um
Ponteiro de nível C (PV). tipo é o código de operação. bandeiras dá os oito bits de
"op_flags". pv fornece o ponteiro de nível C, que deve ter sido alocado usando
"PerlMemShared_malloc"; a memória será liberada quando a operação for destruída.

OP * newPVOP(tipo I32, sinalizadores I32, char *pv)

novoRANGE
Constrói e retorna uma operação "range", com operações subordinadas "flip" e "flop".
bandeiras fornece os oito bits de "op_flags" para a operação "flip" e, deslocado para cima oito
bits, os oito bits de "op_private" para as operações "flip" e "range", exceto
que o bit com valor 1 é definido automaticamente. esquerda e certo fornecer o
expressões controlando os pontos finais do intervalo; eles são consumidos por isso
funcionar e se tornar parte da árvore op construída.

OP * newRANGE(flags I32, OP *esquerda, OP *direita)

novoSLICEOP
Constrói, verifica e retorna uma operação "lslice" (list slice). bandeiras dá
oito bits de "op_flags", exceto que "OPf_KIDS" será definido automaticamente e,
deslocou oito bits, os oito bits de "op_private", exceto que o bit com
o valor 1 ou 2 é definido automaticamente conforme necessário. valor de lista e subscrito fornecer o
parâmetros da fatia; são consumidos por esta função e passam a fazer parte do
árvore op construída.

OP * newSLICEOP(sinalizadores I32, OP *subscrito,
OP *listaval)

novoESTADOOP
Constrói um estado op (COP). O estado op é normalmente um op "nextstate", mas
ser uma operação "dbstate" se a depuração estiver habilitada para o código atualmente compilado. O Estado
op é preenchido a partir de "PL_curcop" (ou "PL_compiling"). Se rótulo não é nulo, é
fornece o nome de um rótulo para anexar ao estado op; esta função leva
posse da memória apontada por rótulo, e irá liberá-lo. bandeiras dá
oito bits de "op_flags" para o estado op.

If o for null, o estado op é retornado. Caso contrário, o estado op é combinado com o
em um op de lista "lineseq", que é retornado. o é consumido por esta função e
torna-se parte da árvore op retornada.

OP * newSTATEOP(sinalizadores I32, char *label, OP *o)

newSVOP Constrói, verifica e retorna um op de qualquer tipo que envolva um SV incorporado.
tipo é o código de operação. bandeiras dá os oito bits de "op_flags". sv dá o SV para
incorporar na operação; esta função se apropria de uma referência a ela.

OP * newSVOP(tipo I32, sinalizadores I32, SV *sv)

newUNOP Constrói, verifica e retorna um op de qualquer tipo unário. tipo é o código de operação.
bandeiras fornece os oito bits de "op_flags", exceto que "OPf_KIDS" será definido
automaticamente, se necessário, e, deslocados oito bits para cima, os oito bits de
"op_private", exceto que o bit com valor 1 é definido automaticamente. primeiro
fornece um op opcional para ser o filho direto do op unário; é consumido por
esta função e se tornar parte da árvore op construída.

OP * novoUNOP(tipo I32, sinalizadores I32, OP *primeiro)

novoUNOP_AUX
Semelhante a "newUNOP", mas cria uma estrutura UNOP_AUX, com op_aux
inicializado para auxiliar

OP* novoUNOP_AUX(tipo I32, sinalizadores I32, OP* primeiro,
UNOP_AUX_item *aux)

novoWHENOP
Constrói, verifica e retorna uma árvore op expressando um bloco "quando". cond
fornece a expressão de teste, e quadra fornece o bloco que será executado
se o teste for avaliado como verdadeiro; são consumidos por esta função e passam a fazer parte
da árvore op construída. cond será interpretado DWIMically, muitas vezes como um
comparação com $_ e pode ser nulo para gerar um bloco "padrão".

OP * novoWHENOP(OP *cond, OP *block)

novoWHILEOP
Constrói, verifica e retorna uma árvore op expressando um loop "while". Isto é um
loop pesado, com estrutura que permite sair do loop por "último" e
semelhantes.

laço é um op "enterloop" pré-construído opcional para usar no loop; se for
null então um op adequado será construído automaticamente. expr fornece o
expressão controladora do loop. quadra fornece o corpo principal do loop, e conta
opcionalmente fornece um bloco "continuar" que funciona como uma segunda metade do corpo.
Todas essas entradas de optree são consumidas por esta função e passam a fazer parte do
árvore op construída.

bandeiras dá os oito bits de "op_flags" para o "leaveloop" e, deslocado para cima
oito bits, os oito bits de "op_private" para o op "leaveloop", exceto que (em
ambos os casos) alguns bits serão definidos automaticamente. depurável está sem uso no momento
e deve ser sempre 1. tem_meu pode ser fornecido como verdadeiro para forçar o corpo do laço a
ser encerrado em seu próprio escopo.

OP * newWHILEOP(sinalizadores I32, I32 depurável,
LOOP *loop, OP *expr, OP *bloco,
OP *cont, I32 tem_meu)

Optree Manipulação Funções

alloccopstash
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Disponível apenas em compilações encadeadas, esta função aloca uma entrada em
"PL_stashpad" para o stash passado para ele.

PADOOFFSET alloccopstash(HV *hv)

fim_do_bloco
Lida com a saída do escopo em tempo de compilação. andar é o índice do savestack retornado por
"block_start" e seq é o corpo do bloco. Retorna o bloco, possivelmente
modificado.

OP * block_end(piso I32, OP *seq)

bloco_início
Manipula a entrada de escopo em tempo de compilação. Organiza para que as dicas sejam restauradas na saída do bloco
e também lida com números de sequência de blocos para fazer com que as variáveis ​​léxicas tenham o escopo correto.
Retorna um índice de savestack para uso com "block_end".

int block_start(int completo)

ck_entersub_args_list
Executa a correção padrão da parte de argumentos de uma árvore op "entersub". Isto
consiste em aplicar contexto de lista a cada uma das operações de argumento. Isto é o
tratamento padrão usado em uma chamada marcada com "&", ou uma chamada de método ou uma chamada
através de uma referência de sub-rotina, ou qualquer outra chamada onde o chamado não pode ser
identificado em tempo de compilação, ou uma chamada onde o chamado não tem protótipo.

OP * ck_entersub_args_list(OP *entersubop)

ck_entersub_args_proto
Executa a correção da parte de argumentos de uma árvore op "entersub" com base em um
protótipo de sub-rotina. Isso faz várias modificações no argumento ops, de
aplicando contexto até a inserção de operações "refgen" e verificando o número e
tipos sintáticos de argumentos, conforme indicado pelo protótipo. Este é o padrão
tratamento usado em uma chamada de sub-rotina, não marcado com "&", onde o chamado pode ser
identificado em tempo de compilação e possui um protótipo.

protosv fornece o protótipo de sub-rotina a ser aplicado à chamada. Pode ser um
escalar definido normal, do qual o valor da string será usado. Alternativamente, para
conveniência, pode ser um objeto de sub-rotina (um "CV*" que foi convertido em "SV*")
que tem um protótipo. O protótipo fornecido, seja qual for a forma, não necessita
para corresponder ao chamado real referenciado pela árvore op.

Se o argumento ops discordar do protótipo, por exemplo, por ter um
um número inaceitável de argumentos, uma árvore op válida é retornada de qualquer maneira. O erro
é refletido no estado do analisador, normalmente resultando em uma única exceção no
nível superior de análise que cobre todos os erros de compilação que ocorreram. Dentro
a mensagem de erro, o chamado é referido pelo nome definido pelo nomegv
parâmetro.

OP *ck_entersub_args_proto(OP *entersubop,
GV *nomegv, SV *protosv)

ck_entersub_args_proto_or_list
Executa a correção da parte de argumentos de uma árvore op "entersub" com base em
um protótipo de sub-rotina ou usando o processamento de contexto de lista padrão. Isto é o
tratamento padrão usado em uma chamada de sub-rotina, não marcado com "&", onde o
chamado pode ser identificado em tempo de compilação.

protosv fornece o protótipo de sub-rotina a ser aplicado à chamada, ou indica
que não há protótipo. Pode ser um escalar normal, caso em que se for
definido, o valor da string será usado como protótipo e, se for indefinido
então não há protótipo. Alternativamente, por conveniência, pode ser um
objeto de subrotina (um "CV*" que foi convertido em "SV*"), do qual o protótipo
será usado se tiver um. O protótipo (ou falta dele) fornecido, em
qualquer forma, não precisa corresponder ao chamado real referenciado pelo op
árvore.

Se o argumento ops discordar do protótipo, por exemplo, por ter um
um número inaceitável de argumentos, uma árvore op válida é retornada de qualquer maneira. O erro
é refletido no estado do analisador, normalmente resultando em uma única exceção no
nível superior de análise que cobre todos os erros de compilação que ocorreram. Dentro
a mensagem de erro, o chamado é referido pelo nome definido pelo nomegv
parâmetro.

OP * ck_entersub_args_proto_or_list(OP *entersubop,
GV *nomegv,
SV *protosv)

cv_const_sv
Se "cv" for uma sub constante elegível para inlining, retornará o valor constante
devolvido pelo sub. Caso contrário, retorna NULL.

Subs constantes podem ser criadas com "newCONSTSUB" ou conforme descrito em "Constant
Funções "em perlsub.

SV* cv_const_sv(const CV *const cv)

cv_get_call_checker
Recupera a função que será usada para corrigir uma chamada para cv. Especificamente,
a função é aplicada a uma árvore op "entersub" para uma chamada de subrotina, não marcada
com "&", onde o chamado pode ser identificado em tempo de compilação como cv.

O ponteiro de função de nível C é retornado em *ckfun_p, e um argumento SV para isso é
voltou em *ckobj_p. A função deve ser chamada desta maneira:

entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p));

Nesta chamada, entrar no subop é um ponteiro para o op "entersub", que pode ser substituído
pela função de verificação, e nomegv é um GV fornecendo o nome que deve ser usado
pela função check para se referir ao chamado da operação "entersub" se precisar
emitir qualquer diagnóstico. É permitido aplicar a função de verificação em
situações, como uma chamada a uma sub-rotina diferente ou a uma chamada de método.

Por padrão, a função é Perl_ck_entersub_args_proto_or_list, e o SV
parâmetro é cv em si. Isso implementa o processamento de protótipo padrão. Pode ser
alterado, para uma sub-rotina específica, por "cv_set_call_checker".

vazio cv_get_call_checker(CV *cv,
Perl_call_checker *ckfun_p,
SV **ckobj_p)

cv_set_call_checker
A forma original de "cv_set_call_checker_flags", que lhe passa o
Sinalizador "CALL_CHECKER_REQUIRE_GV" para compatibilidade com versões anteriores.

vazio cv_set_call_checker(CV *cv,
Perl_call_checker ckfun,
SV *ckobj)

cv_set_call_checker_flags
Define a função que será usada para corrigir uma chamada para cv. Especificamente, o
função é aplicada a uma árvore op "entersub" para uma chamada de subrotina, não marcada
com "&", onde o chamado pode ser identificado em tempo de compilação como cv.

O ponteiro de função de nível C é fornecido em divertido, e um argumento SV para isso é
fornecido em ckobj. A função deve ser definida assim:

OP ESTÁTICO * ckfun(pTHX_ OP *op, GV *namegv, SV *ckobj)

Ele deve ser chamado desta maneira:

entersubop = ckfun(aTHX_ entersubop, namegv, ckobj);

Nesta chamada, entrar no subop é um ponteiro para o op "entersub", que pode ser substituído
pela função de verificação, e nomegv fornece o nome que deve ser usado pelo
verifique a função para se referir ao chamado da operação "entersub" se precisar emitir algum
diagnóstico. É permitido aplicar a função de verificação em
situações, como uma chamada a uma sub-rotina diferente ou a uma chamada de método.

nomegv pode não ser realmente um GV. Para eficiência, o perl pode passar um CV ou outro SV
em vez de. O que quer que seja passado pode ser usado como o primeiro argumento para "cv_name". Você
pode forçar o perl a passar um GV incluindo "CALL_CHECKER_REQUIRE_GV" no bandeiras.

A configuração atual para um determinado CV pode ser recuperada por "cv_get_call_checker".

vazio cv_set_call_checker_flags(
CV *cv, Perl_call_checker ckfun, SV *ckobj,
bandeiras U32
)

LISTA DE LINKS
Dada a raiz de uma optree, vincule a árvore na ordem de execução usando o "op_next"
ponteiros e retornar a primeira operação executada. Se isso já foi feito, será
não será refeito, e "o->op_next" será retornado. Se "o->op_next" ainda não estiver
conjunto, o deve ser pelo menos um "UNOP".

OP* LISTA DE LINKS(OP *o)

novoCONSTSUB
Consulte "newCONSTSUB_flags".

CV* newCONSTSUB(HV* stash, const char* nome, SV* sv)

novoCONSTSUB_flags
Cria uma constante sub equivalente a Perl "sub FOO () { 123 }" que é elegível
para inlining em tempo de compilação.

Atualmente, o único valor útil para "flags" é SVf_UTF8.

A sub-rotina recém-criada se apropria de uma referência ao passado em SV.

Passar NULL para SV cria uma constante sub equivalente a "sub BAR() {}", que
não será chamado se usado como destruidor, mas suprimirá a sobrecarga de uma chamada
para "AUTOLOAD". (Este formulário, no entanto, não é elegível para inlining em tempo de compilação.)

CV* newCONSTSUB_flags(HV* stash, const char* nome,
STRLEN len, sinalizadores U32, SV* sv)

newXS Usado por "xsubpp" para conectar XSUBs como subs Perl. nome do arquivo precisa ser estático
armazenamento, uma vez que é usado diretamente como CvARQUIVO(), sem que seja feita uma cópia.

OpHAS_SIBLING
Retorna verdadeiro se o tiver um irmão

bool OpHAS_SIBLING(OP *o)

OpLASTSIB_set
Marca o como não tendo mais irmãos. Em compilações "PERL_OP_PARENT", marca o como
tendo o pai especificado. Veja também "OpMORESIB_set" e "OpMAYBESIB_set". Para
interface de nível superior, consulte "op_sibling_splice".

void OpLASTSIB_set(OP *o, OP *pai)

OpMAYBESIB_set
Condicionalmente faz "OpMORESIB_set" ou "OpLASTSIB_set" dependendo se o irmão é
não nulo. Para uma interface de nível superior, consulte "op_sibling_splice".

void OpMAYBESIB_set(OP *o, OP *sib, OP *pai)

OpMORESIB_set
Define o irmão de o para o valor diferente de zero sib. Veja também "OpLASTSIB_set" e
"OpMAYBESIB_set". Para uma interface de nível superior, consulte "op_sibling_splice".

void OpMORESIB_set(OP *o, OP *sib)

OBRIGAÇÃO
Retorna o irmão de o, ou NULL se não houver irmão

OP* OpSIBLING(OP *o)

op_append_elem
Anexar um item à lista de operações contidas diretamente em uma operação do tipo lista,
retornando a lista alongada. primeiro é o tipo de lista op, e último é a opção
anexar à lista. tipo de opção especifica o opcode pretendido para a lista. Se primeiro
ainda não for uma lista do tipo certo, ela será atualizada para uma. Se qualquer um
primeiro or último for nulo, o outro será retornado inalterado.

OP * op_append_elem(I32 optype, OP *primeiro, OP *último)

op_append_list
Concatenar as listas de operações contidas diretamente em duas operações do tipo lista,
retornando a lista combinada. primeiro e último são as operações do tipo lista a serem concatenadas.
tipo de opção especifica o opcode pretendido para a lista. Se qualquer um primeiro or último não é
já uma lista do tipo certo, ela será atualizada para uma. Se qualquer um primeiro
or último for nulo, o outro será retornado inalterado.

OP * op_append_list(I32 optype, OP *primeiro, OP *último)

OP_CLASS
Retorna a classe do OP fornecido: ou seja, qual das estruturas *OP ele usa.
Para operações principais, isso atualmente obtém as informações de PL_opargs, que não
sempre refletem com precisão o tipo usado. Para operações personalizadas, o tipo é retornado de
o registro, e cabe ao registrador garantir que esteja correto. O
valor retornado será uma das constantes OA_* de op.h.

U32 OP_CLASS(OP *o)

op_contextualizar
Aplica um contexto sintático a uma árvore op representando uma expressão. o é a operação
árvore, e contexto deve ser "G_SCALAR", "G_ARRAY" ou "G_VOID" para especificar o
contexto a ser aplicado. A árvore op modificada é retornada.

OP * op_contextualize(OP *o, contexto I32)

op_convert_list
Converte o em um op de lista, se ainda não for um, e depois o converte no
especificada tipo, chamando sua função de verificação, alocando um destino se precisar de um,
e constantes de dobra.

Uma operação do tipo lista geralmente é construída uma criança de cada vez por meio de "newLISTOP",
"op_prepend_elem" e "op_append_elem". Então, finalmente, é passado para
"op_convert_list" para torná-lo o tipo certo.

OP * op_convert_list(tipo I32, sinalizadores I32, OP *o)

OP_DESC Retorna uma breve descrição do OP fornecido.

const char * OP_DESC(OP *o)

op_free Libera um op. Use isso apenas quando um op não estiver mais vinculado a nenhuma optree.

vazio op_free(OP *o)

op_linklist
Esta função é a implementação da macro "LINKLIST". Não deveria ser
chamado diretamente.

OP* op_linklist(OP *o)

valor_op
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Propagar o contexto lvalue ("modificável") para um op e seus filhos. tipo
representa o tipo de contexto, aproximadamente baseado no tipo de operação que faria o
modificando, embora "local()" seja representado por OP_NULL, pois não possui tipo op
próprio (é sinalizado por um sinalizador no lvalue op).

Esta função detecta coisas que não podem ser modificadas, como "$x+1", e gera
erros para eles. Por exemplo, "$x+1 = 2" faria com que fosse chamado com um op
do tipo OP_ADD e um argumento "tipo" de OP_SASSIGN.

Ele também sinaliza coisas que precisam se comportar especialmente em um contexto lvalue, como
"$$x = 5" que pode ter que animar uma referência em $x.

OP * op_lvalue(OP *o, tipo I32)

OP_NAME Retorna o nome do OP fornecido. Para operações principais, isso procura o nome do
op_type; para operações personalizadas do op_ppaddr.

const char * OP_NAME(OP *o)

op_null Neutraliza uma operação quando ela não é mais necessária, mas ainda está vinculada a outras
operações.

vazio op_null(OP *o)

op_parent
Retorna o OP pai de o, se tiver um pai. Retorna NULL caso contrário. Isto
A função só está disponível em perls construídos com "-DPERL_OP_PARENT".

OP* op_parent(OP *o)

op_prepend_elem
Anexe um item à lista de operações contidas diretamente em uma operação do tipo lista,
retornando a lista alongada. primeiro é o op para preceder a lista, e último
é o tipo de lista op. tipo de opção especifica o opcode pretendido para a lista. Se último
ainda não for uma lista do tipo certo, ela será atualizada para uma. Se qualquer um
primeiro or último for nulo, o outro será retornado inalterado.

OP * op_prepend_elem(I32 optype, OP *primeiro, OP *último)

escopo_op
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Envolve uma árvore de operações com algumas operações adicionais para que, em tempo de execução, um escopo dinâmico
Será criado. As operações originais são executadas no novo escopo dinâmico e, em seguida,
desde que saiam normalmente, o escopo será desenrolado. As operações adicionais
usado para criar e desenrolar o escopo dinâmico normalmente será um "enter"/"leave"
par, mas uma operação de "escopo" pode ser usada se as operações forem simples o suficiente para não
precisa da estrutura de escopo dinâmica completa.

OP * op_scope(OP * o)

op_sibling_splice
Uma função geral para editar a estrutura de uma cadeia existente de op_sibling
nós. Por analogia com o nível perl splice () função, permite que você exclua
zero ou mais nós sequenciais, substituindo-os por zero ou mais nós diferentes.
Executa a limpeza necessária op_first/op_last no nó pai e
manipulação de op_sibling nas crianças. O último nó excluído será marcado como
como o último nó atualizando o campo op_sibling/op_sibparent ou op_moresib como
apropriado.

Observe que op_next não é manipulado e os nós não são liberados; esse é o
responsabilidade do chamador. Ele também não criará uma nova operação de lista para um vazio
lista etc; use funções de nível superior como op_append_elem() por isso.

parent é o nó pai da cadeia de irmãos. Pode ser passado como NULL se o
a emenda não afeta a primeira ou a última operação da cadeia.

start é o nó que precede o primeiro nó a ser emendado. Nó(s) seguindo-o
será deletado e as operações serão inseridas depois dele. Se for NULL, o primeiro nó
em diante é excluído e os nós são inseridos no início.

del_count é o número de nós a serem excluídos. Se zero, nenhum nó é excluído. Se -1
ou maior ou igual ao número de filhos restantes, todos os filhos restantes são
excluída.

insert é o primeiro de uma cadeia de nós a ser inserido no lugar dos nós. Se
NULL, nenhum nó é inserido.

O cabeçalho da cadeia de operações excluídas é retornado ou NULL se nenhuma operação foi excluída.

Por exemplo:

ação antes depois retornos
------ ----- ----- -------

PP
emenda(P, A, 2, XYZ) | | BC
ABCD AXYZD

PP
emenda(P, NULL, 1, XY) | | UMA
ABCD XYBCD

PP
emenda(P, NULO, 3, NULO) | | abc
ABCD D

PP
emenda(P, B, 0, XY) | | NULO
ABCD ABXYCD

Para manipulação direta de nível inferior de "op_sibparent" e "op_moresib", consulte
"OpMORESIB_set", "OpLASTSIB_set", "OpMAYBESIB_set".

OP* op_sibling_splice(OP *pai, OP *inicial,
int del_count, OP* inserir)

OP_TYPE_IS
Retorna true se o OP fornecido não for um ponteiro NULL e se for do tipo fornecido.

A negação desta macro, "OP_TYPE_ISNT" também está disponível, bem como
"OP_TYPE_IS_NN" e "OP_TYPE_ISNT_NN" que eliminam a verificação do ponteiro NULL.

bool OP_TYPE_IS(OP *o, Tipo de opção)

OP_TYPE_IS_OR_WAS
Retorna true se o OP fornecido não for um ponteiro NULL e se for do tipo fornecido
ou costumava ser antes de ser substituído por um OP do tipo OP_NULL.

A negação desta macro, "OP_TYPE_ISNT_AND_WASNT" também está disponível, bem como
"OP_TYPE_IS_OR_WAS_NN" e "OP_TYPE_ISNT_AND_WASNT_NN" que eliminam o NULL
verificação do ponteiro.

bool OP_TYPE_IS_OR_WAS(OP *o, Tipo de opção)

rv2cv_op_cv
Examina um op, que deve identificar uma sub-rotina em tempo de execução e
tenta determinar em tempo de compilação qual sub-rotina ele identifica. Isto é
normalmente usado durante a compilação Perl para determinar se um protótipo pode ser
aplicado a uma chamada de função. CVOP é o op que está sendo considerado, normalmente um "rv2cv"
op. Um ponteiro para a sub-rotina identificada é retornado, se puder ser determinado
estaticamente, e um ponteiro nulo é retornado se não for possível determinar
estatisticamente.

Atualmente, a sub-rotina pode ser identificada estaticamente se o RV que o "rv2cv"
deve operar é fornecido por um op "gv" ou "const" adequado. Uma operação "gv" é
adequado se o slot de CV do GV ​​estiver preenchido. Uma operação "const" é adequada se o
valor constante deve ser um RV apontando para um CV. Os detalhes deste processo podem mudar
em versões futuras do Perl. Se o op "rv2cv" tiver o sinalizador "OPpENTERSUB_AMPER"
definido, nenhuma tentativa é feita para identificar a sub-rotina estaticamente: este sinalizador é
usado para suprimir a magia de tempo de compilação em uma chamada de sub-rotina, forçando-a a usar
comportamento de tempo de execução padrão.

If bandeiras tem o bit "RV2CVOPCV_MARK_EARLY" definido, então o tratamento de um GV
referência é modificada. Se um GV foi examinado e seu slot de CV foi encontrado para ser
vazio, então o op "gv" tem o sinalizador "OPpEARLY_CV" definido. Se a operação não for
otimizado, e o slot CV é posteriormente preenchido com uma sub-rotina com um
protótipo, esse sinalizador eventualmente aciona o aviso "chamado muito cedo para verificar
protótipo".

If bandeiras tem o bit "RV2CVOPCV_RETURN_NAME_GV" definido, então ao invés de retornar um
ponteiro para a sub-rotina ele retorna um ponteiro para o GV dando o maior
nome apropriado para a sub-rotina neste contexto. Normalmente este é apenas o
"CvGV" da sub-rotina, mas para uma sub-rotina anônima ("CvANON") que é
referenciado por meio de um GV, será o GV de referência. O "GV*" resultante é
cast para "CV*" a ser retornado. Um ponteiro nulo é retornado como de costume se não houver
sub-rotina estaticamente determinável.

CV * rv2cv_op_cv(OP *cvop, sinalizadores U32)

Pack e Desembalar

lista de embalagem
O motor que implementa pacote() Função Perl.

void packlist(SV *cat, const char *pat,
const char *patend, SV **beglist,
SV **lista final)

descompactar
O motor que implementa o desempacotar () Função Perl.

Usando o template pat..patend, esta função desempacota a string s..strend em um
número de SVs mortais, que ele empurra para a pilha de argumentos perl (@_) (para que você
precisará emitir um "PUTBACK" antes e "SPAGAIN" após a chamada para este
função). Ele retorna o número de elementos enviados.

Os ponteiros strend e patend devem apontar para o byte após o último
caractere de cada string.

Embora esta função retorne seus valores na pilha de argumentos perl, ela não
pegue quaisquer parâmetros dessa pilha (e, portanto, em particular, não há necessidade de fazer
um PUSHMARK antes de chamá-lo, ao contrário de "call_pv" por exemplo).

I32 unpackstring(const char *pat,
const char *patend, const char *s,
const char *trend, sinalizadores U32)

Almofada Data Estruturas

CvPADLIST
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Os CVs podem ter CvPADLIST(cv) definido para apontar para um PADLIST. Este é o currículo
scratchpad, que armazena variáveis ​​léxicas e opcode temporários e por thread
valores.

Para estes efeitos, os "formatos" são uma espécie de CV; eval""s também são (exceto que não são
podem ser chamados à vontade e são sempre descartados após a execução do eval"").
Arquivos obrigatórios são simplesmente evals sem qualquer escopo lexical externo.

XSUBs não têm um CvPADLIST. dXSTARG busca valores de PL_curpad, mas isso é
realmente o bloco de chamadores (um slot do qual é alocado por cada entersub). Não
obter ou definir CvPADLIST se um CV for um XSUB (conforme determinado por "CvISXSUB()"), CvPADLIST
slot é reutilizado para uma finalidade interna diferente em XSUBs.

O PADLIST possui um array C onde os pads são armazenados.

A 0ª entrada do PADLIST é um PADNAMELIST que representa os "nomes" ou
em vez disso, as "informações de tipo estático" para léxicos. Os elementos individuais de um
PADNAMELIST são PADNAMEs. Refatorações futuras podem parar o PADNAMELIST de
sendo armazenado no array do PADLIST, então não confie nele. Consulte "PadlistNAMES".

A entrada CvDEPTH'th de um PADLIST é um PAD (um AV) que é o quadro de pilha em
essa profundidade de recursão no CV. O slot 0 de um quadro AV é um AV que é
@_. Outras entradas são armazenamento para variáveis ​​e destinos operacionais.

A iteração sobre o PADNAMELIST itera sobre todos os itens de pad possíveis. Ranhuras para almofadas
para destinos (SVs_PADTMP) e GVs acabam tendo &PL_padname_undef "nomes", enquanto
slots para constantes têm &PL_padname_const "nomes" (veja pad_alloc()) Este
&PL_padname_undef e &PL_padname_const são usados ​​é um detalhe de implementação
sujeito a mudanças. Para testá-los, use "!PadnamePV(name)" e "PadnamePV(name)
&& !PadnameLEN(nome)", respectivamente.

Apenas meus/nossos slots de variáveis ​​obtêm nomes válidos. O resto são alvos operacionais/GVs/constantes
que são alocados estaticamente ou resolvidos em tempo de compilação. Estes não tem
nomes pelos quais eles podem ser consultados no código Perl em tempo de execução através de eval"" o
como minhas/nossas variáveis ​​podem ser. Como eles não podem ser pesquisados ​​por "nome", mas apenas por
seu índice alocado em tempo de compilação (que geralmente está em PL_op->op_targ),
desperdiçar um nome SV para eles não faz sentido.

Os nomes dos pads em PADNAMELIST têm seus PVs contendo o nome da variável.
Os campos COP_SEQ_RANGE_LOW e _HIGH formam um intervalo (low+1..high inclusive) de
cop_seq números para os quais o nome é válido. Durante a compilação, esses campos podem
mantenha o valor especial PERL_PADSEQ_INTRO para indicar vários estágios:

COP_SEQ_RANGE_LOW _ALTO
------ -----
PERL_PADSEQ_INTRO 0 variável ainda não introduzida:
{ meu ($ x
valid-seq# variável PERL_PADSEQ_INTRO no escopo:
{ meu ($x)
valid-seq# valid-seq# compilação do escopo concluída:
{ meu ($x) }

Para léxicos digitados, PadnameTYPE aponta para o tipo stash. Para "nossos" léxicos,
PadnameOURSTASH aponta para o stash do global associado (para que duplicatas
"nossas" declarações no mesmo pacote podem ser detectadas). PadnameGEN às vezes é
usado para armazenar o número de geração durante a compilação.

Se PadnameOUTER estiver definido no nome do pad, então esse slot no quadro AV é um
Referência REFCNT'ed a um léxico de "fora". Tais entradas são, por vezes,
conhecido como 'falso'. Neste caso, o nome não usa 'baixo' e 'alto' para
armazene um intervalo cop_seq, uma vez que está no escopo por toda parte. Em vez de lojas 'altas'
alguns sinalizadores contendo informações sobre o léxico real (é declarado em um anon, e
é capaz de ser instanciado várias vezes?), e para ANONs falsos, 'baixo'
contém o índice dentro do bloco do pai onde o valor do léxico é armazenado, para
tornar a clonagem mais rápida.

Se o 'nome' for '&' a entrada correspondente no PAD é um CV representando um
possível fechamento.

Observe que os formatos são tratados como subs anon e são clonados cada vez que a gravação é
chamado (se necessário).

O sinalizador SVs_PADSTALE é apagado nos léxicos cada vez que o minha() é executado, e
definido na saída do escopo. Isso permite que o aviso 'Variável $x não está disponível' seja
gerado em avaliações, como

{ meu $x = 1; sub f { eval '$x'} } f();

Para vars de estado, SVs_PADSTALE está sobrecarregado para significar 'ainda não inicializado', mas isso
o estado interno é armazenado em uma entrada de pad separada.

LISTA PADL * CvLISTA PADL(CV *cv)

PadARRAY
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

A matriz C de entradas de pad.

SV ** PadARRAY (almofada PAD)

Lista de PadsARRAY
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

A matriz C de uma lista de pads, contendo os pads. Apenas subscreva com números >=
1, pois não é garantido que a 0ª entrada permaneça utilizável.

PAD ** PadlistARRAY(lista de pads PADLIST)

PadlistMAX
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

O índice do último espaço alocado na lista de teclados. Observe que o último bloco pode
estar em um slot anterior. Quaisquer entradas seguintes serão NULL nesse caso.

SSize_t PadlistMAX(lista de pads PADLIST)

Lista de PadrõesNAMES
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Os nomes associados às entradas do bloco.

PADNAMELIST * PadlistNAMES(PADLIST padlist)

Lista de PadsNAMESARRAY
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

A matriz C de nomes de pads.

PADNAME ** PadlistNAMESARRAY(PADLIST padlist)

Lista de PadrõesNAMESMAX
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

O índice do último nome do bloco.

SSize_t PadlistNAMESMAX(PADLIST Padlist)

Lista de PadsREFCNT
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

A contagem de referência do padlist. Atualmente, isso é sempre 1.

U32 PadlistREFCNT(lista de teclados PADLIST)

PadMAX NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

O índice da última entrada do bloco.

SSize_t PadMAX(pad pad)

Padname LEN
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

O comprimento do nome.

STRLEN PadnameLEN(PADNAME pn)

Lista de PadnamesARRAY
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

A matriz C de nomes de pads.

PADNAME ** PadnamelistARRAY(PADNAMELIST pnl)

Lista de PadnamesMAX
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

O índice do último nome do bloco.

SSize_t PadnamelistMAX(PADNAMELIST pnl)

Lista de padnamesREFCNT
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

A contagem de referência da lista de nomes de pads.

SSize_t PadnamelistREFCNT(PADNAMELIST pnl)

PadnamelistREFCNT_dec
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Reduz a contagem de referência da lista de nomes de pads.

void PadnamelistREFCNT_dec(PADNAMELIST pnl)

PadnamePV
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

O nome armazenado na estrutura do nome do pad. Isso retorna NULL para um slot de destino.

char * PadnamePV(PADNAME pn)

PadnameREFCNT
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

A contagem de referência do nome do bloco.

SSize_t PadnameREFCNT(PADNAME pn)

PadnameREFCNT_dec
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Reduz a contagem de referência do nome do bloco.

void PadnameREFCNT_dec(PADNAME pn)

PadnameSV
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Retorna o nome do pad como um SV mortal.

SV * PadnameSV(PADNAME pn)

PadnameUTF8
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Se PadnamePV está em UTF8. Atualmente, isso é sempre verdade.

bool PadnameUTF8(PADNAME pn)

pad_add_name_pvs
Exatamente como "pad_add_name_pvn", mas leva uma string literal em vez de um
par string / comprimento.

PADOFFSET pad_add_name_pvs(const char *name, sinalizadores U32,
HV * typestash, HV * ourstash)

pad_findmy_pvs
Exatamente como "pad_findmy_pvn", mas leva uma string literal em vez de um
par string / comprimento.

PADOFFSET pad_findmy_pvs(const char *nome, sinalizadores U32)

pad_new Cria uma nova lista de pads, atualizando as variáveis ​​globais para a compilação atual
padlist para apontar para o novo padlist. Os seguintes sinalizadores podem ser combinados com OR:

padnew_CLONE este bloco é para um CV clonado
padnew_SAVE salva globais antigos na pilha de salvamento
padnew_SAVESUB também salva coisas extras para o início do sub

PADLIST * pad_new(int sinalizadores)

PL_comppad
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Durante a compilação, isso aponta para o array contendo os valores que fazem parte do pad
para o código atualmente compilado. (Em tempo de execução, um CV pode ter muitos valores
matrizes; em tempo de compilação, apenas um é construído.) Em tempo de execução, isso aponta para o
array contendo os valores atualmente relevantes para o pad para o
código de execução.

PL_comppad_name
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Durante a compilação, isso aponta para o array contendo os nomes que fazem parte do pad
para o código atualmente compilado.

PL_curpad
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Aponta diretamente para o corpo do array "PL_comppad". (Isto é
"PAD_ARRAY(PL_comppad)".)

Por intérprete Variáveis

PL_modglobal
"PL_modglobal" é um HV global interpretador de propósito geral para uso por extensões
que precisam manter as informações por intérprete. Em uma pitada, também pode
ser usado como uma tabela de símbolos para extensões para compartilhar dados entre si. É um
boa ideia usar chaves prefixadas pelo nome do pacote da extensão que possui o
dados.

HV* PL_modglobal

PL_na Uma variável de conveniência que normalmente é usada com "SvPV" quando não se importa
sobre o comprimento da corda. Geralmente é mais eficiente declarar um
local e use-a em vez disso ou use a macro "SvPV_nolen".

STRLEN PL_na

PL_opfreehook
Quando não-"NULL", a função apontada por esta variável será chamada cada vez que um
OP é liberado com o OP correspondente como argumento. Isso permite que as extensões
liberar qualquer atributo extra que eles tenham anexado localmente a um OP. Também é assegurado
para disparar primeiro para o OP pai e depois para seus filhos.

Ao substituir essa variável, é considerado uma boa prática armazenar o
possivelmente instalado anteriormente e que você o recupere dentro do seu.

Perl_opook_t PL_opfreehook

PL_peepp
Ponteiro para o otimizador de olho mágico por sub-rotina. Esta é uma função que obtém
chamado no final da compilação de uma sub-rotina Perl (ou equivalente
pedaço de código Perl) para realizar correções de algumas operações e realizar pequenas
otimizações. A função é chamada uma vez para cada sub-rotina compilada,
e é passado, como único parâmetro, um ponteiro para o op que é o ponto de entrada para
a sub-rotina. Ele modifica a árvore operacional no local.

O otimizador de olho mágico nunca deve ser completamente substituído. Em vez disso, adicione código a
envolvendo o otimizador existente. A maneira básica de fazer isso pode ser vista em
"Compile pass 3: peephole optimization" em perlguts. Se o novo código desejar
operar em operações em toda a estrutura da sub-rotina, em vez de apenas no topo
nível, é provável que seja mais conveniente envolver o gancho "PL_rpeepp".

peep_t PL_peepp

PL_rpeepp
Ponteiro para o otimizador de olho mágico recursivo. Esta é uma função que é chamada
no final da compilação de uma sub-rotina Perl (ou peça equivalentemente independente
de código Perl) para realizar correções de algumas operações e realizar
otimizações. A função é chamada uma vez para cada cadeia de operações vinculada por
seus campos "op_next"; ele é chamado recursivamente para lidar com cada cadeia lateral. Isto é
passou, como único parâmetro, um ponteiro para o op que está no início da cadeia.
Ele modifica a árvore operacional no local.

O otimizador de olho mágico nunca deve ser completamente substituído. Em vez disso, adicione código a
envolvendo o otimizador existente. A maneira básica de fazer isso pode ser vista em
"Compile pass 3: peephole optimization" em perlguts. Se o novo código desejar
operam apenas em operações no nível superior de uma sub-rotina, em vez de em todo o
estrutura, é provável que seja mais conveniente envolver o gancho "PL_peepp".

peep_t PL_rpeepp

PL_sv_no
Este é o SV "falso". Consulte "PL_sv_yes". Sempre se refira a isso como &PL_sv_no.

SV PL_sv_no

PL_sv_undef
Este é o SV "undef". Sempre se refira a isso como &PL_sv_undef.

SV PL_sv_undef

PL_sv_yes
Este é o "verdadeiro" SV. Consulte "PL_sv_no". Sempre se refira a isso como &PL_sv_yes.

SV PL_sv_sim

REGEXP Funções

Macro de conveniência SvRX para obter o REGEXP de um SV. Isso é aproximadamente equivalente
ao seguinte trecho:

if (SvMÁGICO(sv))
mg_get(sv);
se (SvROK(sv))
sv = MUTABLE_SV(SvRV(sv));
if (SvTYPE(sv) == SVt_REGEXP)
retornar (REGEXP*) sv;

NULL será retornado se um REGEXP* não for encontrado.

REGEXP * SvRX(SV *sv)

SvRXOK Retorna um booleano indicando se o SV (ou aquele que ele referencia) é um
REGEXP.

Se você quiser fazer algo com o REGEXP* mais tarde, use SvRX e verifique
NULO.

bool SvRXOK(SV* sv)

Pilha Manipulação Macros

dMARK Declare uma variável de marcador de pilha, "mark", para o XSUB. Consulte "MARCA" e
"dORIGMARK".

dMARCO;

dORIGMARK
Salva a marca de pilha original para o XSUB. Consulte "ORIGMARK".

dORIGMARK;

dSP Declara uma cópia local do ponteiro de pilha do perl para o XSUB, disponível através do "SP"
macro. Consulte "SP".

dSP;

EXTEND Usado para estender a pilha de argumentos para os valores de retorno de um XSUB. Uma vez usado,
garante que há espaço para pelo menos "nitems" serem empurrados para a pilha.

void EXTEND(SP, SSize_t itens)

MARK Variável de marcador de pilha para o XSUB. Consulte "dMARK".

mPUSHi Empurra um inteiro para a pilha. A pilha deve ter espaço para este elemento. Faz
não use "TARG". Consulte também "PUSHi", "mXPUSHi" e "XPUSHi".

anular mPUSHi(IV iv)

mPUSHn Empurre um duplo para a pilha. A pilha deve ter espaço para este elemento. Faz
não use "TARG". Consulte também "PUSHn", "mXPUSHn" e "XPUSHn".

nulo mPUSHn(NV nv)

mPUSHp Empurra uma string para a pilha. A pilha deve ter espaço para este elemento. O
"len" indica o comprimento da string. Não usa "TARG". Veja também "PUSHp",
"mXPUSHp" e "XPUSHp".

void mPUSHp(char* str, STRLEN len)

mPUSHs Empurra um SV para a pilha e mortaliza o SV. A pilha deve ter espaço para
este elemento. Não usa "TARG". Consulte também "PUSHs" e "mXPUSHs".

anular mPUSHs(SV* sv)

mPUSHu Empurre um inteiro sem sinal para a pilha. A pilha deve ter espaço para isso
elemento. Não usa "TARG". Consulte também "PUSHu", "mXPUSHu" e "XPUSHu".

vazio mPUSHu(UV uv)

mXPUSHi Empurre um inteiro para a pilha, estendendo a pilha se necessário. Não usa
"TARG". Consulte também "XPUSHi", "mPUSHi" e "PUSHi".

vazio mXPUSHi(IV iv)

mXPUSHn Empurre um duplo para a pilha, estendendo a pilha se necessário. Não usa
"TARG". Consulte também "XPUSHn", "mPUSHn" e "PUSHn".

vazio mXPUSHn(NV nv)

mXPUSHp Empurre uma string para a pilha, estendendo a pilha se necessário. O "len"
indica o comprimento da string. Não usa "TARG". Veja também "XPUSHp",
"mPUSHp" e "PUSHp".

void mXPUSHp(char* str, STRLEN len)

mXPUSHs Empurra um SV para a pilha, estendendo a pilha se necessário e mortalizando o SV.
Não usa "TARG". Consulte também "XPUSHs" e "mPUSHs".

anular mXPUSHs(SV* sv)

mXPUSHu Empurre um inteiro sem sinal para a pilha, estendendo a pilha se necessário. Faz
não use "TARG". Consulte também "XPUSHu", "mPUSHu" e "PUSHu".

vazio mXPUSHu (UV uv)

MARCA ORIGINAL
A marca de pilha original para o XSUB. Consulte "dORIGMARK".

POPi Retira um inteiro da pilha.

IV POPi

POPl Sai muito da pilha.

POPl longo

POPn Retira um duplo da pilha.

NV POP n

POPp Retira uma string da pilha.

caractere* POP

POPbytex
Retira uma string da pilha que deve consistir em bytes, ou seja, caracteres < 256.

char* POPbytex

POPpx Retira uma string da pilha. Idêntico ao POP. Existem dois nomes para
razões históricas.

caractere* POPpx

POPs Retira um SV da pilha.

SV* POPs

PUSHi Empurre um inteiro para a pilha. A pilha deve ter espaço para este elemento.
Lida com a magia 'set'. Usa "TARG", então "dTARGET" ou "dXSTARG" devem ser chamados para
declará-lo. Não chame várias macros orientadas a "TARG" para retornar listas de
XSUB's - veja "mPUSHi" em vez disso. Consulte também "XPUSHi" e "mXPUSHi".

nulo PUSHi (IV iv)

MARCA
Abrindo colchetes para argumentos em um retorno de chamada. Veja "PUTBACK" e perlcall.

anular PUSHMARK(SP)

PUSH mortal
Empurre um novo SV mortal para a pilha. A pilha deve ter espaço para este elemento.
Não usa "TARG". Veja também "PUSHs", "XPUSHmortal" e "XPUSHs".

vazio PUSHmortal()

PUSHn Empurre um duplo para a pilha. A pilha deve ter espaço para este elemento. Alças
'definir' magia. Usa "TARG", então "dTARGET" ou "dXSTARG" devem ser chamados para declarar
isto. Não chame múltiplas macros orientadas a "TARG" para retornar listas de XSUB's - veja
"mPUSHn" em vez disso. Consulte também "XPUSHn" e "mXPUSHn".

vazio PUSHn(NV nv)

PUSHp Empurra uma string para a pilha. A pilha deve ter espaço para este elemento. O
"len" indica o comprimento da string. Lida com a magia 'set'. Usa "TARG", então
"dTARGET" ou "dXSTARG" deve ser chamado para declará-lo. Não ligue para vários
Macros orientadas a "TARG" para retornar listas de XSUB's - consulte "mPUSHp" em vez disso. Ver
também "XPUSHp" e "mXPUSHp".

vazio PUSHp(char* str, STRLEN len)

PUSHs Empurra um SV para a pilha. A pilha deve ter espaço para este elemento. Não
lidar com a magia 'set'. Não usa "TARG". Veja também "PUSHmortal", "XPUSHs" e
"XPUSHmortal".

PUSHs vazios (SV* sv)

PUSHu Empurre um inteiro sem sinal para a pilha. A pilha deve ter espaço para isso
elemento. Lida com a magia 'set'. Usa "TARG", então "dTARGET" ou "dXSTARG" devem ser
chamado para declará-lo. Não chame várias macros orientadas a "TARG" para retornar listas
de XSUB - veja "mPUSHu" em vez disso. Consulte também "XPUSHu" e "mXPUSHu".

vazio PUSHu (UV uv)

PUTBACK Colchete de fechamento para argumentos XSUB. Isso geralmente é tratado por "xsubpp". Ver
"PUSHMARK" e perlcall para outros usos.

POR DE VOLTA;

Ponteiro de pilha SP. Isso geralmente é tratado por "xsubpp". Consulte "dSP" e "SPAGAIN".

SPAGAIN Recarregue o ponteiro da pilha. Usado após um retorno de chamada. Veja perlcall.

ESPANHA;

XPUSHi Empurre um inteiro para a pilha, estendendo a pilha se necessário. Manipula 'conjunto'
Magia. Usa "TARG", então "dTARGET" ou "dXSTARG" deve ser chamado para declará-lo. Fazer
não chame várias macros orientadas a "TARG" para retornar listas de XSUB's - consulte
"mXPUSHi" em vez disso. Consulte também "PUSHi" e "mPUSHi".

nulo XPUSHi(IV iv)

XPUSH mortal
Empurre um novo SV mortal para a pilha, estendendo a pilha se necessário. Não
use "TARG". Veja também "XPUSHs", "PUSHmortal" e "PUSHs".

vazio XPUSHmortal()

XPUSHn Empurre um duplo na pilha, estendendo a pilha se necessário. Manipula 'conjunto'
Magia. Usa "TARG", então "dTARGET" ou "dXSTARG" deve ser chamado para declará-lo. Fazer
não chame várias macros orientadas a "TARG" para retornar listas de XSUB's - consulte
"mXPUSHn" em vez disso. Consulte também "PUSHn" e "mPUSHn".

nulo XPUSHn(NV nv)

XPUSHp Empurre uma string para a pilha, estendendo a pilha, se necessário. O "len"
indica o comprimento da string. Lida com a magia 'set'. Usa "TARG", então
"dTARGET" ou "dXSTARG" deve ser chamado para declará-lo. Não ligue para vários
Macros orientadas a "TARG" para retornar listas de XSUB's - consulte "mXPUSHp" em vez disso. Ver
também "PUSHp" e "mPUSHp".

void XPUSHp(char* str, STRLEN len)

XPUSHs Empurra um SV para a pilha, estendendo a pilha, se necessário. Não atende
'definir' magia. Não usa "TARG". Veja também "XPUSHmortal", "PUSHs" e
"PUSHmortal".

void XPUSHs(SV*sv)

XPUSHu Empurre um inteiro sem sinal para a pilha, estendendo a pilha se necessário.
Lida com a magia 'set'. Usa "TARG", então "dTARGET" ou "dXSTARG" devem ser chamados para
declará-lo. Não chame várias macros orientadas a "TARG" para retornar listas de
XSUB's - veja "mXPUSHu" em vez disso. Consulte também "PUSHu" e "mPUSHu".

vazio XPUSHu (UV uv)

XSRETURN
Retorno de XSUB, indicando o número de itens na pilha. Isso geralmente
manipulado por "xsubpp".

void XSRETURN(int nitens)

XSRETURN_EMPTY
Retorna uma lista vazia de um XSUB imediatamente.

XSRETURN_EMPTY;

XSRETURN_IV
Retorna um inteiro de um XSUB imediatamente. Usa "XST_mIV".

vazio XSRETURN_IV(IV iv)

XSRETURN_NO
Retorne &PL_sv_no de um XSUB imediatamente. Usa "XST_mNO".

XSRETURN_NO;

XSRETURN_NV
Devolva um double de um XSUB imediatamente. Usa "XST_mNV".

vazio XSRETURN_NV(NV nv)

XSRETURN_PV
Retorne uma cópia de uma string de um XSUB imediatamente. Usa "XST_mPV".

vazio XSRETURN_PV(char*str)

XSRETURN_UNDEF
Retorne &PL_sv_undef de um XSUB imediatamente. Usa "XST_mUNDEF".

XSRETURN_UNDEF;

XSRETURN_UV
Retorna um inteiro de um XSUB imediatamente. Usa "XST_mUV".

vazio XSRETURN_UV(IV uv)

XSRETURN_YES
Retorne &PL_sv_yes de um XSUB imediatamente. Usa "XST_mYES".

XSRETURN_SIM;

XST_mIV Coloca um inteiro na posição especificada "pos" na pilha. O valor é
armazenado em um novo SV mortal.

vazio XST_mIV(int pos, IV iv)

XST_mNO Coloque &PL_sv_no na posição especificada "pos" na pilha.

vazio XST_mNO(int pos)

XST_mNV Coloque um duplo na posição especificada "pos" na pilha. O valor é
armazenado em um novo SV mortal.

vazio XST_mNV(int pos, NV nv)

XST_mPV Coloca uma cópia de uma string na posição especificada "pos" na pilha. O
valor é armazenado em um novo SV mortal.

void XST_mPV(int pos, char* str)

XST_mUNDEF
Coloque &PL_sv_undef na posição especificada "pos" na pilha.

vazio XST_mUNDEF(int pos)

XST_mSIM
Coloque &PL_sv_yes na posição especificada "pos" na pilha.

vazio XST_mYES(int pos)

SV Bandeiras

svtype Uma enumeração de sinalizadores para tipos Perl. Estes são encontrados no arquivo sv.h no "svtype"
enum. Teste esses sinalizadores com a macro "SvTYPE".

Os tipos são:

SVt_NULL
SVt_IV
SVt_NV
SVt_RV
SVt_PV
SVt_PVIV
SVt_PVNV
SVt_PVMG
SVt_INVLIST
SVt_REGEXP
SVt_PVGV
SVt_PVLV
SVt_PVAV
SVt_PVHV
SVt_PVCV
SVt_PVFM
SVt_PVIO

Estes são mais facilmente explicados de baixo para cima.

SVt_PVIO é para objetos de E/S, SVt_PVFM para formatos, SVt_PVCV para sub-rotinas,
SVt_PVHV para hashes e SVt_PVAV para arrays.

Todos os outros são tipos escalares, ou seja, coisas que podem ser vinculadas a um "$"
variável. Para estes, os tipos internos são em sua maioria ortogonais aos tipos no
Linguagem Perl.

Portanto, verificar "SvTYPE(sv) < SVt_PVAV" é a melhor maneira de ver se algo
é um escalar.

SVt_PVGV representa um typeglob. Se !SvFAKE(sv), então é um real, incoercível
typeglob. Se SvFAKE(sv), então é um escalar para o qual um typeglob foi
atribuído. Atribuir a ele novamente o impedirá de ser um typeglob. SVt_PVLV
representa um escalar que delega a outro escalar nos bastidores. Isto é
usado, por exemplo, para o valor de retorno de "substr" e para elementos hash e array vinculados.
Ele pode conter qualquer valor escalar, incluindo um typeglob. SVt_REGEXP é para regular
expressões. SVt_INVLIST é apenas para uso interno do núcleo Perl.

SVt_PVMG representa um escalar "normal" (não um typeglob, expressão regular ou
delegar). Como a maioria dos escalares não precisa de todos os campos internos de um PVMG,
economize memória alocando estruturas menores quando possível. Todos os outros tipos são
apenas formas mais simples de SVt_PVMG, com menos campos internos.
SVt_NULL só pode conter undef. SVt_IV pode conter undef, um inteiro ou uma referência.
(SVt_RV é um alias para SVt_IV, que existe para compatibilidade com versões anteriores.) SVt_NV
pode conter qualquer um desses ou um duplo. SVt_PV só pode conter undef ou uma string.
SVt_PVIV é um superconjunto de SVt_PV e SVt_IV. SVt_PVNV é semelhante. SVt_PVMG pode
segurar qualquer coisa que o SVt_PVNV possa segurar, mas pode, mas não precisa, ser abençoado ou
mágico.

SVt_INVLIST
Digite sinalizador para escalares. Veja "svtype".

SVt_IV Sinalizador de tipo para escalares. Veja "svtype".

SVt_NULL
Digite sinalizador para escalares. Veja "svtype".

SVt_NV Sinalizador de tipo para escalares. Veja "svtype".

SVt_PV Sinalizador de tipo para escalares. Veja "svtype".

SVt_PVAV
Digite sinalizador para matrizes. Veja "svtype".

SVt_PVCV
Sinalizador de tipo para sub-rotinas. Veja "svtype".

SVt_PVFM
Digite sinalizador para formatos. Veja "svtype".

SVt_PVGV
Sinalizador de tipo para typeglobs. Veja "svtype".

SVt_PVHV
Digite sinalizador para hashes. Veja "svtype".

SVt_PVIO
Sinalizador de tipo para objetos de E/S. Veja "svtype".

SVt_PVIV
Digite sinalizador para escalares. Veja "svtype".

SVt_PVLV
Digite sinalizador para escalares. Veja "svtype".

SVt_PVMG
Digite sinalizador para escalares. Veja "svtype".

SVt_PVNV
Digite sinalizador para escalares. Veja "svtype".

SVt_REGEXP
Sinalizador de tipo para expressões regulares. Veja "svtype".

SV Manipulação Funções

boolSV Retorna um SV verdadeiro se "b" for um valor verdadeiro ou um SV falso se "b" for 0.

Veja também "PL_sv_yes" e "PL_sv_no".

SV * boolSV(bool b)

croak_xs_usage
Uma variante especializada de "croak()" para emitir a mensagem de uso para xsubs

croak_xs_usage(cv, "eee_yow");

calcula o nome do pacote e o nome da sub-rotina de "cv", e então chama
"coar()". Portanto, se "cv" for &ouch::awk, ele chamaria "croak" como:

Perl_croak(aTHX_ "Uso: %"SVf"::%"SVf"(%s)", "ai" "awk",
"eee_yow");

void croak_xs_usage(const CV *const CV,
const char *const parâmetros)

get_sv Retorna o SV do escalar Perl especificado. "flags" são passados ​​para "gv_fetchpv".
Se "GV_ADD" for definido e a variável Perl não existir, ela será criada.
Se "sinalizadores" for zero e a variável não existir, NULL será retornado.

NOTA: a forma perl_ desta função está obsoleta.

SV* get_sv(const char *name, sinalizadores I32)

novoRV_inc
Cria um wrapper RV para um SV. A contagem de referência para o SV original é
incrementado.

SV* novoRV_inc(SV* sv)

novoSVpadname
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Cria um novo SV contendo o nome do pad.

SV* novoSVpadname(PADNAME *pn)

novoSVpvn_utf8
Cria um novo SV e copia uma string (que pode conter caracteres "NUL" ("\0"))
afim disso. Se utf8 for verdadeiro, chama "SvUTF8_on" no novo SV. Implementado como um
wrapper em torno de "newSVpvn_flags".

SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len,
U32 utf8)

SvCUR Retorna o comprimento da string que está no SV. Consulte "SvLEN".

STRLEN SvCUR(SV* sv)

SvCUR_set
Defina o comprimento atual da string que está no SV. Consulte "SvCUR" e
"SvIV_set".

void SvCUR_set(SV* sv, STRLEN len)

SvEND Retorna um ponteiro para o ponto logo após o último caractere na string que é
no SV, onde geralmente há um caractere "NUL" à direita (mesmo que Perl
escalares não exigem isso estritamente). Consulte "SvCUR". Acesse o personagem como
*(SvEND(sv)).

Aviso: Se "SvCUR" for igual a "SvLEN", então "SvEND" aponta para não alocado
memória.

char* SvEND(SV* sv)

SvGAMAGIC
Retorna true se o SV tiver magia ou sobrecarga. Se qualquer um for verdade, então o
escalar são dados ativos e tem o potencial de retornar um novo valor toda vez que
é acessado. Portanto, você deve ter o cuidado de lê-lo apenas uma vez por usuário lógico
operação e trabalhar com esse valor retornado. Se nenhum for verdadeiro, então o escalar
valor não pode mudar a menos que seja gravado.

U32 SvGAMAGIC(SV*sv)

SvGROW Expande o buffer de caracteres no SV para que haja espaço para o
número de bytes (lembre-se de reservar espaço para um caractere "NUL" extra à direita).
Chama "sv_grow" para realizar a expansão se necessário. Retorna um ponteiro para o
buffer de caracteres. SV deve ser do tipo >= SVt_PV. Uma alternativa é ligar
"sv_grow" se você não tiver certeza do tipo de SV.

char * SvGROW(SV* sv, STRLEN len)

SvIOK Retorna um valor U32 indicando se o SV contém um número inteiro.

U32 SvIOK(SV*sv)

SvIOKp Retorna um valor U32 indicando se o SV contém um número inteiro. Verifica o
privado contexto. Use "SvIOK" em vez disso.

U32 SvIOKp(SV*sv)

SvIOK_notUV
Retorna um booleano indicando se o SV contém um inteiro com sinal.

bool SvIOK_notUV(SV* sv)

SvIOK_off
Desativa o status IV de um SV.

void SvIOK_off(SV* sv)

SvIOK_on
Diz a um SV que é um número inteiro.

void SvIOK_on(SV* sv)

SvIOK_only
Diz a um SV que é um inteiro e desabilita todos os outros bits OK.

void SvIOK_only(SV* sv)

SvIOK_only_UV
Diz a um SV que é um inteiro sem sinal e desabilita todos os outros bits OK.

vazio SvIOK_only_UV(SV* sv)

SvIOK_UV
Retorna um booleano indicando se o SV contém um inteiro que deve ser
interpretado como não assinado. Um número inteiro não negativo cujo valor está dentro do intervalo
de um IV e um UV podem ser sinalizados como SvUOK ou SVIOK.

bool SvIOK_UV(SV* sv)

SvIsCOW Retorna um valor U32 indicando se o SV é Copy-On-Write (ou hash compartilhado
escalares de chave ou escalares completos Copy On Write se 5.9.0 estiver configurado para COW).

U32 SvIsCOW(SV*sv)

SvIsCOW_shared_hash
Retorna um booleano indicando se o SV é uma chave de hash compartilhada Copy-On-Write
escalar.

bool SvIsCOW_shared_hash(SV* sv)

SvIV Força o SV fornecido para um inteiro e o retorna. Veja "SvIVx" para uma versão
que garante avaliar sv apenas uma vez.

IV SvIV(SV* sv)

SvIVX Retorna o valor bruto no slot IV do SV, sem verificações ou conversões. Apenas
use quando tiver certeza de que o SvIOK é verdadeiro. Consulte também "SvIV()".

IV SvIVX(SV* sv)

SvIVx Força o SV fornecido para um inteiro e o retorna. Garantias para avaliar "sv"
apenas uma vez. Use isso apenas se "sv" for uma expressão com efeitos colaterais, caso contrário
use o "SvIV" mais eficiente.

IV SvIVx(SV* sv)

SvIV_nomg
Como "SvIV", mas não processa mágica.

IV SvIV_nomg(SV* sv)

SvIV_set
Defina o valor do ponteiro IV em sv para val. É possível realizar o mesmo
função desta macro com uma atribuição de lvalue para "SvIVX". Com o futuro Perls,
no entanto, será mais eficiente usar "SvIV_set" em vez do lvalue
atribuição para "SvIVX".

void SvIV_set(SV* sv, IV val)

SvLEN Retorna o tamanho do buffer de string no SV, sem incluir nenhuma parte
atribuível a "SvOOK". Consulte "SvCUR".

STRLEN SvLEN(SV* sv)

SvLEN_set
Defina o comprimento real da string que está no SV. Consulte "SvIV_set".

void SvLEN_set(SV* sv, STRLEN len)

SvMAGIC_set
Defina o valor do ponteiro MAGIC em sv para val. Consulte "SvIV_set".

void SvMAGIC_set(SV* sv, MAGIC* val)

SvNIOK Retorna um valor U32 indicando se o SV contém um número, inteiro ou
Duplo.

U32 SvNIOK(SV*sv)

SvNIOKp Retorna um valor U32 indicando se o SV contém um número, inteiro ou
em dobro. Verifica o privado contexto. Use "SvNIOK" em vez disso.

U32 SvNIOKp(SV*sv)

SvNIOK_off
Desativa o status NV/IV de um SV.

void SvNIOK_off(SV* sv)

SvNOK Retorna um valor U32 indicando se o SV contém um duplo.

U32 SvNOK(SV*sv)

SvNOKp Retorna um valor U32 indicando se o SV contém um duplo. Verifica o
privado contexto. Use "SvNOK" em vez disso.

U32 SvNOKp(SV*sv)

SvNOK_off
Desativa o status NV de um SV.

vazio SvNOK_off(SV* sv)

SvNOK_on
Diz a um SV que é um duplo.

vazio SvNOK_on(SV* sv)

SvNOK_only
Diz a um SV que é um double e desabilita todos os outros bits OK.

void SvNOK_only(SV* sv)

SvNV Coagir o SV dado para um double e devolvê-lo. Veja "SvNVx" para uma versão que
garante avaliar sv apenas uma vez.

NV SvNV(SV*sv)

SvNVX Retorna o valor bruto no slot NV do SV, sem verificações ou conversões. Apenas
use quando tiver certeza de que SvNOK é verdadeiro. Consulte também "SvNV()".

NV SvNVX(SV* sv)

SvNVx Força o SV dado para um double e o retorna. Garantias para avaliar apenas "sv"
uma vez. Use isso apenas se "sv" for uma expressão com efeitos colaterais, caso contrário, use o
mais eficiente "SvNV".

NV SvNVx(SV* sv)

SvNV_nomg
Como "SvNV", mas não processa mágica.

NV SvNV_nomg(SV* sv)

SvNV_set
Defina o valor do ponteiro NV em sv para val. Consulte "SvIV_set".

void SvNV_set(SV* sv, NV val)

SvOK Retorna um valor U32 indicando se o valor está definido. Isso é apenas
significativo para escalares.

U32 SvOK(SV*sv)

SvOOK Retorna um U32 indicando se o ponteiro para o buffer de string está deslocado. este
hack é usado internamente para acelerar a remoção de caracteres desde o início de um
SvPV. Quando SvOOK é verdadeiro, o início do buffer de string alocado é
na verdade bytes "SvOOK_offset()" antes de SvPVX. Este deslocamento costumava ser armazenado em
SvIVX, mas agora está armazenado na parte sobressalente do buffer.

U32 SvOOK(SV*sv)

SvOOK_offset
Lê em len o deslocamento de SvPVX de volta para o verdadeiro início do alocado
buffer, que será diferente de zero se "sv_chop" tiver sido usado para remover com eficiência
caracteres do início do buffer. Implementado como uma macro, que leva o
endereço de len, que deve ser do tipo "STRLEN". Avalia sv mais de uma vez.
Conjuntos len para 0 se "SvOOK(sv)" for falso.

void SvOOK_offset(NN SV*sv, STRLEN len)

SvPOK Retorna um valor U32 indicando se o SV contém uma cadeia de caracteres.

U32 SvPOK(SV*sv)

SvPOKp Retorna um valor U32 indicando se o SV contém uma cadeia de caracteres. Verificações
da privado contexto. Use "SvPOK" em vez disso.

U32 SvPOKp(SV*sv)

SvPOK_off
Desativa o status PV de um SV.

void SvPOK_off(SV* sv)

SvPOK_on
Diz a um SV que é uma string.

vazio SvPOK_on(SV* sv)

SvPOK_only
Diz a um SV que é uma string e desabilita todos os outros bits OK. Também vai virar
fora do status UTF-8.

void SvPOK_only(SV* sv)

SvPOK_only_UTF8
Diz a um SV que é uma string e desabilita todos os outros bits OK, e deixa o
Status UTF-8 como era.

void SvPOK_only_UTF8(SV* sv)

SvPV Retorna um ponteiro para a string no SV, ou uma forma de string do SV se o
SV não contém uma string. O SV pode armazenar em cache a versão stringificada tornando-se
"SvPOK". Lida com a magia 'get'. A variável "len" será definida para o comprimento de
a string (esta é uma macro, então não use &len). Veja também "SvPVx" para uma versão
que garante avaliar sv apenas uma vez.

Observe que não há garantia de que o valor de retorno de "SvPV()" seja igual a
"SvPVX(sv)", ou que "SvPVX(sv)" contém dados válidos, ou que chamadas sucessivas para
"SvPV(sv)" retornará o mesmo valor de ponteiro todas as vezes. Isso se deve à maneira
que coisas como sobrecarga e Copy-On-Write sejam tratadas. Nestes casos, o
o valor de retorno pode apontar para um buffer temporário ou similar. Se você absolutamente precisa
o campo SvPVX seja válido (por exemplo, se você pretende gravar nele), consulte
"SvPV_force".

char* SvPV(SV* sv, STRLEN len)

SvPVbyte
Como "SvPV", mas converte sv em representação de byte primeiro, se necessário.

char* SvPVbyte(SV* sv, STRLEN len)

SvPVbytex
Como "SvPV", mas converte sv em representação de byte primeiro, se necessário.
Garantias para avaliar sv apenas uma vez; use o mais eficiente "SvPVbyte" caso contrário.

char* SvPVbytex(SV* sv, STRLEN len)

SvPVbytex_force
Como "SvPV_force", mas converte sv em representação de byte primeiro, se necessário.
Garantias para avaliar sv apenas uma vez; use o "SvPVbyte_force" mais eficiente
de outra forma.

char* SvPVbytex_force(SV* sv, STRLEN len)

SvPVbyte_force
Como "SvPV_force", mas converte sv em representação de byte primeiro, se necessário.

char* SvPVbyte_force(SV* sv, STRLEN len)

SvPVbyte_nolen
Como "SvPV_nolen", mas converte sv para representação de byte primeiro, se necessário.

char* SvPVbyte_nolen(SV* sv)

SvPVutf8
Como "SvPV", mas converte sv para utf8 primeiro, se necessário.

char* SvPVutf8(SV* sv, STRLEN len)

SvPVutf8x
Como "SvPV", mas converte sv para utf8 primeiro, se necessário. Garantias para avaliar
sv apenas uma vez; use o mais eficiente "SvPVutf8" caso contrário.

char* SvPVutf8x(SV* sv, STRLEN len)

SvPVutf8x_force
Como "SvPV_force", mas converte sv para utf8 primeiro, se necessário. Garantias para
avalie sv apenas uma vez; use o mais eficiente "SvPVutf8_force" caso contrário.

char* SvPVutf8x_force(SV* sv, STRLEN len)

SvPVutf8_force
Como "SvPV_force", mas converte sv para utf8 primeiro, se necessário.

char* SvPVutf8_force(SV* sv, STRLEN len)

SvPVutf8_nolen
Como "SvPV_nolen", mas converte sv para utf8 primeiro, se necessário.

char* SvPVutf8_nolen(SV* sv)

SvPVX Retorna um ponteiro para a string física no SV. O SV deve conter uma string.
Antes de 5.9.3 não é seguro executar esta macro a menos que o tipo do SV >=
SVt_PV.

Isso também é usado para armazenar o nome de uma sub-rotina autocarregada em um XS AUTOLOAD
rotina. Consulte "Carregamento automático com XSUBs" em perlguts.

char* SvPVX(SV* sv)

SvPVx Uma versão de "SvPV" que garante avaliar "sv" apenas uma vez. Só use isso se
"sv" é uma expressão com efeitos colaterais, caso contrário, use o "SvPV" mais eficiente.

char* SvPVx(SV* sv, STRLEN len)

SvPV_force
Como "SvPV", mas forçará o SV a conter uma string ("SvPOK") e apenas um
string ("SvPOK_only"), por gancho ou por bandido. Você precisa de força se quiser
atualize o "SvPVX" diretamente. Os processos ficam mágicos.

Observe que coagir um escalar arbitrário em um PV simples potencialmente removerá
dados úteis dele. Por exemplo, se o SV for "SvROK", o referente será
ter sua contagem de referência diminuída, e o próprio SV pode ser convertido em um
Escalar "SvPOK" com um buffer de string contendo um valor como "ARRAY(0x1234)".

char* SvPV_force(SV* sv, STRLEN len)

SvPV_force_nomg
Como "SvPV_force", mas não processa a magia.

char* SvPV_force_nomg(SV* sv, STRLEN len)

SvPV_nolen
Como "SvPV", mas não define uma variável de comprimento.

char* SvPV_nolen(SV* sv)

SvPV_nomg
Como "SvPV", mas não processa mágica.

char* SvPV_nomg(SV* sv, STRLEN len)

SvPV_nomg_nolen
Como "SvPV_nolen", mas não processa mágica.

char* SvPV_nomg_nolen(SV* sv)

SvPV_set
Isso provavelmente não é o que você deseja usar, provavelmente queria "sv_usepvn_flags"
ou "sv_setpvn" ou "sv_setpvs".

Defina o valor do ponteiro PV em "sv" para o Perl alocado com "NUL" terminado
cadeia "val". Consulte também "SvIV_set".

Lembre-se de liberar o buffer PV anterior. Há muitas coisas para verificar. Cuidado
que o ponteiro existente pode estar envolvido em copy-on-write ou outro dano, então
faça "SvOOK_off(sv)" e use "sv_force_normal" ou "SvPV_force" (ou verifique o SvIsCOW
flag) primeiro para garantir que essa modificação seja segura. Então, finalmente, se não for um
COW, chame "SvPV_free" para liberar o buffer PV anterior.

void SvPV_set(SV* sv, char* val)

SvREFCNT
Retorna o valor da contagem de referência do objeto.

U32 SvREFCNT(SV*sv)

SvREFCNT_dec
Diminui a contagem de referência do SV fornecido. sv pode ser NULO.

void SvREFCNT_dec(SV* sv)

SvREFCNT_dec_NN
O mesmo que SvREFCNT_dec, mas só pode ser usado se você souber sv não é nulo. Desde que nós
não precisa verificar o NULLness, é mais rápido e menor.

vazio SvREFCNT_dec_NN(SV* sv)

SvREFCNT_inc
Incrementa a contagem de referência do SV fornecido, retornando o SV.

Todas as macros SvREFCNT_inc* a seguir são versões otimizadas de SvREFCNT_inc,
e pode ser substituído por SvREFCNT_inc.

SV* SvREFCNT_inc(SV* sv)

SvREFCNT_inc_NN
O mesmo que SvREFCNT_inc, mas só pode ser usado se você souber sv não é nulo. Desde que nós
não precisa verificar o NULLness, é mais rápido e menor.

SV* SvREFCNT_inc_NN(SV* sv)

SvREFCNT_inc_simple
O mesmo que SvREFCNT_inc, mas só pode ser usado com expressões sem efeitos colaterais.
Como não precisamos armazenar um valor temporário, é mais rápido.

SV* SvREFCNT_inc_simple(SV* sv)

SvREFCNT_inc_simple_NN
O mesmo que SvREFCNT_inc_simple, mas só pode ser usado se você souber sv não é nulo.
Como não precisamos verificar o NULLness, é mais rápido e menor.

SV* SvREFCNT_inc_simple_NN(SV* sv)

SvREFCNT_inc_simple_void
Igual a SvREFCNT_inc_simple, mas só pode ser usado se você não precisar do retorno
valor. A macro não precisa retornar um valor significativo.

vazio SvREFCNT_inc_simple_void(SV* sv)

SvREFCNT_inc_simple_void_NN
O mesmo que SvREFCNT_inc, mas só pode ser usado se você não precisar do valor de retorno e
Você sabe disso sv não é nulo. A macro não precisa retornar um
value ou verifique se há NULLness, para que seja menor e mais rápido.

vazio SvREFCNT_inc_simple_void_NN(SV* sv)

SvREFCNT_inc_void
O mesmo que SvREFCNT_inc, mas só pode ser usado se você não precisar do valor de retorno.
A macro não precisa retornar um valor significativo.

vazio SvREFCNT_inc_void(SV* sv)

SvREFCNT_inc_void_NN
O mesmo que SvREFCNT_inc, mas só pode ser usado se você não precisar do valor de retorno e
Você sabe disso sv não é nulo. A macro não precisa retornar um
value ou verifique se há NULLness, para que seja menor e mais rápido.

vazio SvREFCNT_inc_void_NN(SV* sv)

SvROK Testa se o SV é um RV.

U32 SvROK(SV*sv)

SvROK_off
Desativa o status de RV de um SV.

vazio SvROK_off(SV* sv)

SvROK_on
Diz a um SV que é um RV.

vazio SvROK_on(SV* sv)

SvRV Desreferencia um RV para retornar o SV.

SV*SvRV(SV*sv)

SvRV_set
Defina o valor do ponteiro RV em sv para val. Consulte "SvIV_set".

vazio SvRV_set(SV* sv, SV* val)

SvSTASH Retorna o stash do SV.

HV* SvSTASH(SV*sv)

SvSTASH_set
Defina o valor do ponteiro STASH em sv para val. Consulte "SvIV_set".

void SvSTASH_set(SV* sv, HV* val)

SvTAINT Contamina um SV se a contaminação estiver habilitada e se alguma entrada para a expressão atual
está contaminado - geralmente uma variável, mas possivelmente também entradas implícitas, como locale
definições. "SvTAINT" propaga essa contaminação para as saídas de uma expressão
de forma pessimista; isto é, sem prestar atenção precisamente em quais
saídas são influenciadas por quais entradas.

void SvTAINT(SV* sv)

MANTIDO
Verifica se um SV está contaminado. Retorna TRUE se for, FALSE se não for.

bool SvTAINTED(SV* sv)

SvTAINTED_off
Descontamina um SV. Ser muito cuidado com essa rotina, pois causa curto-circuito em alguns
Recursos de segurança fundamentais do Perl. Os autores do módulo XS não devem usar isso
funcionar a menos que compreendam completamente todas as implicações de
desvinculando o valor. A descontaminação deve ser feita da maneira perl padrão, via
uma regexp cuidadosamente elaborada, em vez de variáveis ​​que descontaminam diretamente.

void SvTAINTED_off(SV* sv)

SvTAINTED_on
Marca um SV como contaminado se a contaminação estiver ativada.

void SvTAINTED_on(SV* sv)

SvTRUE Retorna um booleano indicando se Perl avaliaria o SV como verdadeiro ou falso.
See SvOK () para um teste definido/indefinido. Manipula a magia 'get' a menos que o escalar seja
já SvPOK, SvIOK ou SvNOK (os sinalizadores públicos, não os privados).

bool SvTRUE(SV* sv)

SvTRUE_nomg
Retorna um booleano indicando se Perl avaliaria o SV como verdadeiro ou falso.
See SvOK () para um teste definido/indefinido. Não lida com magia 'get'.

bool SvTRUE_nomg(SV* sv)

SvTYPE Retorna o tipo do SV. Veja "svtype".

svtype SvTYPE(SV* sv)

SvUOK Retorna um booleano indicando se o SV contém um inteiro que deve ser
interpretado como não assinado. Um número inteiro não negativo cujo valor está dentro do intervalo
de um IV e um UV podem ser sinalizados como SvUOK ou SVIOK.

bool SvUOK(SV* sv)

SvUPGRADE
Usado para atualizar um SV para uma forma mais complexa. Usa "sv_upgrade" para realizar a
atualize se necessário. Veja "svtype".

void SvUPGRADE(SV* sv, tipo svtype)

SvUTF8 Retorna um valor U32 indicando o status UTF-8 de um SV. Se as coisas estão configuradas
corretamente, isso indica se o SV contém ou não dados codificados em UTF-8. Você
deveria usar isso depois de uma chamada para SvPV () ou uma de suas variantes, caso qualquer chamada para
sobrecarga de string atualiza o sinalizador interno.

Se você quiser levar em conta o pragma de bytes, use "DO_UTF8" em vez disso.

U32 SvUTF8(SV*sv)

SvUTF8_off
Desativa o status UTF-8 de um SV (os dados não são alterados, apenas o sinalizador). Não faça
usar frivolamente.

void SvUTF8_off(SV *sv)

SvUTF8_on
Ative o status UTF-8 de um SV (os dados não são alterados, apenas o sinalizador). Fazer
não use frivolamente.

vazio SvUTF8_on(SV *sv)

SvUV Força o SV fornecido para um inteiro sem sinal e o retorna. Consulte "SvUVx" para uma
versão que garante avaliar sv apenas uma vez.

UV SvUV(SV*sv)

SvUVX Retorna o valor bruto no slot UV do SV, sem verificações ou conversões. Apenas
use quando tiver certeza de que o SvIOK é verdadeiro. Consulte também "SvUV()".

UV SvUVX(SV*sv)

SvUVx Força o SV fornecido para um inteiro sem sinal e o retorna. Garantias para
avalie "sv" apenas uma vez. Use isso apenas se "sv" for uma expressão com lado
efeitos, caso contrário, use o "SvUV" mais eficiente.

UV SvUVx(SV*sv)

SvUV_nomg
Como "SvUV", mas não processa mágica.

UVSvUV_nomg(SV* sv)

SvUV_set
Defina o valor do ponteiro UV em sv para val. Consulte "SvIV_set".

void SvUV_set(SV* sv, UV val)

SvVOK Retorna um booleano indicando se o SV contém uma v-string.

bool SvVOK(SV* sv)

sv_catpvn_nomg
Como "sv_catpvn", mas não processa mágica.

void sv_catpvn_nomg(SV* sv, const char* ptr,
STRLEN Len)

sv_catpv_nomg
Como "sv_catpv", mas não processa mágica.

void sv_catpv_nomg(SV* sv, const char* ptr)

sv_catsv_nomg
Como "sv_catsv", mas não processa mágica.

vazio sv_catsv_nomg(SV* dsv, SV* ssv)

sv_derived_from
Exatamente como "sv_derived_from_pv", mas não recebe um parâmetro "flags".

bool sv_derived_from(SV* sv, const char *const nome)

sv_derived_from_pv
Exatamente como "sv_derived_from_pvn", mas usa uma string terminada em nul em vez de uma
par string / comprimento.

bool sv_derived_from_pv(SV* sv,
const char *const nome,
Sinalizadores U32)

sv_derived_from_pvn
Retorna um booleano indicando se o SV é derivado da classe especificada at
da C nível. Para verificar a derivação no nível Perl, chame "isa()" como um Perl normal
método.

Atualmente, o único valor significativo para "sinalizadores" é SVf_UTF8.

bool sv_derived_from_pvn(SV* sv,
const char *const nome,
const STRLEN len, sinalizadores U32)

sv_derived_from_sv
Exatamente como "sv_derived_from_pvn", mas leva a string de nome na forma de um SV
em vez de um par string / comprimento.

bool sv_derived_from_sv(SV* sv, SV *nomesv,
Sinalizadores U32)

sv_does Como "sv_does_pv", mas não recebe um parâmetro "flags".

bool sv_does(SV* sv, const char *const nome)

sv_does_pv
Como "sv_does_sv", mas recebe uma string terminada em nulo em vez de um SV.

bool sv_does_pv(SV* sv, const char *const nome,
Sinalizadores U32)

sv_does_pvn
Como "sv_does_sv", mas leva um par string/comprimento em vez de um SV.

bool sv_does_pvn(SV* sv, const char *const nome,
const STRLEN len, sinalizadores U32)

sv_does_sv
Retorna um booleano que indica se o SV executa uma função nomeada específica. o
SV pode ser um objeto Perl ou o nome de uma classe Perl.

bool sv_does_sv(SV* sv, SV* nomesv, sinalizadores U32)

sv_report_usado
Despeje o conteúdo de todos os SVs ainda não liberados (ajuda de depuração).

vazio sv_report_used()

sv_setsv_nomg
Como "sv_setsv", mas não processa mágica.

vazio sv_setsv_nomg(SV* dsv, SV* ssv)

sv_utf8_upgrade_nomg
Como sv_utf8_upgrade, mas não faz mágica em "sv".

STRLEN sv_utf8_upgrade_nomg(NN SV *sv)

Corpo SV Alocação

look_like_number
Teste se o conteúdo de um SV se parece com um número (ou é um número). "Inf" e
"Infinito" são tratados como números (portanto, não emitirá um aviso não numérico), mesmo
se o seu atof () não os groca. Get-magic é ignorado.

I32 look_like_number(SV *const sv)

novoRV_noinc
Cria um wrapper RV para um SV. A contagem de referência para o SV original é não
incrementado.

SV* novoRV_noinc(SV *const tmpRef)

newSV Cria um novo SV. Um parâmetro "len" diferente de zero indica o número de bytes de
espaço de string pré-alocado que o SV deve ter. Um byte extra para um "NUL" à direita
também é reservado. (SvPOK não está definido para o SV mesmo se o espaço da string for
alocado.) A contagem de referência para o novo SV é definida como 1.

Em 5.9.3, foi fundada a novoSV() substitui o antigo NOTÍCIASV() API e descarta o primeiro parâmetro,
x, um auxílio de depuração que permitia que os chamadores se identificassem. Esta ajuda foi
substituído por uma nova opção de compilação, PERL_MEM_LOG (consulte "PERL_MEM_LOG" em
perlhacktips). A API mais antiga ainda está disponível para uso em módulos XS que suportam
perls mais velhos.

SV* novoSV(const STRLEN len)

novoSVhek
Cria um novo SV a partir da estrutura de chave de hash. Ele irá gerar escalares que apontam
para a tabela de string compartilhada sempre que possível. Retorna um novo SV (indefinido) se o
hehe é NULL.

SV* novoSVhek(const HEK *const hek)

newSViv Cria um novo SV e copia um inteiro nele. A contagem de referência para o SV é
definido como 1.

SV* novoSViv(const IV i)

newSVnv Cria um novo SV e copia um valor de ponto flutuante nele. A contagem de referência
para o SV é definido como 1.

SV* novoSVnv(const NV n)

newSVpv Cria um novo SV e copia uma string (que pode conter caracteres "NUL" ("\0"))
afim disso. A contagem de referência para o SV é definida como 1. Se "len" for zero, Perl
calcule o comprimento usando strlen (), (o que significa que se você usar esta opção, esse "s"
não pode ter caracteres "NUL" incorporados e deve ter um byte "NUL" de terminação).

Para eficiência, considere usar "newSVpvn" em vez disso.

SV* novoSVpv(const char *const s, const STRLEN len)

novoSVpvf
Cria um novo SV e o inicializa com a string formatada como "sprintf".

SV* novoSVpvf(const char *const pat, ...)

novoSVpvn
Cria um novo SV e copia uma string nele, que pode conter caracteres "NUL"
("\0") e outros dados binários. A contagem de referência para o SV é definida como 1. Observação
que se "len" for zero, o Perl criará uma string de comprimento zero (Perl). Tu es
responsável por garantir que o buffer de origem tenha pelo menos "len" bytes. Se
o argumento "buffer" é NULL o novo SV será indefinido.

SV* novoSVpvn(const char *const s, const STRLEN len)

novoSVpvn_flags
Cria um novo SV e copia uma string (que pode conter caracteres "NUL" ("\0"))
afim disso. A contagem de referência para o SV é definida como 1. Observe que, se "len" for zero,
Perl criará uma string de comprimento zero. Você é responsável por garantir que o
string de origem tem pelo menos "len" bytes. Se o argumento "s" for NULL o novo
SV será indefinido. Atualmente os únicos bits de flag aceitos são "SVf_UTF8" e
"SVs_TEMP". Se "SVs_TEMP" estiver definido, "sv_2mortal()" será chamado no resultado
antes de retornar. Se "SVf_UTF8" estiver definido, "s" será considerado em UTF-8 e o
O sinalizador "SVf_UTF8" será definido no novo SV. "newSVpvn_utf8()" é uma conveniência
wrapper para esta função, definida como

#define newSVpvn_utf8(s, len, u) \
newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)

SV* novoSVpvn_flags(const char *const s,
const STRLEN lente,
sinalizadores const U32)

novoSVpvn_share
Cria um novo SV com seu SvPVX_const apontando para uma string compartilhada na string
tabela. Se a string ainda não existir na tabela, ela será criada primeiro.
Ativa o sinalizador SvIsCOW (ou READONLY e FAKE na versão 5.16 e anterior). Se o
parâmetro "hash" é diferente de zero, esse valor é usado; caso contrário, o hash é calculado.
O hash da string pode ser recuperado posteriormente do SV com o "SvSHARED_HASH()"
macro. A ideia aqui é que, como a tabela de strings é usada para chaves de hash compartilhadas
essas strings terão SvPVX_const == HeKEY e a pesquisa de hash evitará string
comparar.

SV* newSVpvn_share(const char* s, I32 len, U32 hash)

novoSVpvs
Como "newSVpvn", mas recebe uma string literal terminada em "NUL" em vez de uma
par string / comprimento.

SV* novoSVpvs(const char* s)

novoSVpvs_flags
Como "newSVpvn_flags", mas recebe uma string literal terminada em "NUL" em vez de uma
par string / comprimento.

SV* newSVpvs_flags(const char* s, sinalizadores U32)

novoSVpvs_share
Como "newSVpvn_share", mas recebe uma string literal terminada em "NUL" em vez de uma
string/comprimento e omite o parâmetro hash.

SV* novoSVpvs_share(const char*s)

novoSVpv_share
Como "newSVpvn_share", mas recebe uma string terminada em "NUL" em vez de uma
par string / comprimento.

SV* newSVpv_share(const char* s, hash U32)

newSVrv Cria um novo SV para o RV existente, "rv", para apontar. Se "rv" não for um RV
então ele será atualizado para um. Se "classname" não for nulo, o novo SV será
ser abençoado no pacote especificado. O novo SV é retornado e sua referência
contagem é 1. A contagem de referência 1 é de propriedade de "rv".

SV* novoSVrv(SV *const rv,
const char * const classname)

newSVsv Cria um novo SV que é uma duplicata exata do SV original. (Usa
"sv_setsv".)

SV* novoSVsv(SV *const antigo)

newSVuv Cria um novo SV e copia um inteiro sem sinal para ele. A contagem de referência para
o SV é definido como 1.

SV* novoSVuv(const UV u)

novoSV_type
Cria um novo SV, do tipo especificado. A contagem de referência para o novo SV é
definido como 1.

SV* novoSV_type(const tipo svtype)

sv_2bool
Esta macro só é usada por sv_true() ou seu equivalente macro, e somente se o
o argumento deste último não é SvPOK, SvIOK nem SvNOK. Ele chama sv_2bool_flags com
o sinalizador SV_GMAGIC.

bool sv_2bool(SV *const sv)

sv_2bool_flags
Esta função é usada apenas por sv_true() e amigos, e somente se este último
argumento não é SvPOK, SvIOK nem SvNOK. Se os sinalizadores contiverem SV_GMAGIC, então
ele faz um mg_get() em primeiro lugar.

bool sv_2bool_flags(SV *sv, sinalizadores I32)

sv_2cv Usando vários gambits, tente obter um CV de um SV; além disso, tente se possível
defina *st e *gvp para o stash e GV associado a ele. As bandeiras em "lref" são
passado para gv_fetchsv.

CV* sv_2cv(SV* sv, HV **const st, GV **const gvp,
const I32 lref)

sv_2io Usando vários gambits, tente obter um IO de um SV: o slot IO se for um GV; ou
o resultado recursivo se formos um RV; ou o slot IO do símbolo com o nome do
PV se formos uma string.

A magia 'Get' é ignorada no sv passado, mas será chamada em "SvRV(sv)" se sv
é um RV.

IO* sv_2io(SV *const sv)

sv_2iv_flags
Retorna o valor inteiro de um SV, fazendo qualquer conversão de string necessária. Se
flags inclui SV_GMAGIC, faz um mg_get() primeiro. Normalmente utilizado através do
Macros "SvIV(sv)" e "SvIVx(sv)".

IV sv_2iv_flags(SV *const sv, const I32 sinalizadores)

sv_2mortal
Marca um SV existente como mortal. O SV será destruído "em breve", seja por um
chamada explícita para FREETMPS, ou por uma chamada implícita em locais como instrução
limites. SvTEMP() está ligado, o que significa que o buffer de string do SV pode ser
"roubado" se este SV for copiado. Veja também "sv_newmortal" e "sv_mortalcopy".

SV* sv_2mortal(SV *const sv)

sv_2nv_flags
Retorna o valor num de um SV, fazendo qualquer conversão de string ou inteiro necessária.
Se os sinalizadores incluem SV_GMAGIC, faz um mg_get() primeiro. Normalmente utilizado através do
Macros "SvNV(sv)" e "SvNVx(sv)".

NV sv_2nv_flags(SV *const sv, const I32 sinalizadores)

sv_2pvbyte
Retorne um ponteiro para a representação codificada por byte do SV e defina *lp para seu
comprimento. Pode fazer com que o SV seja rebaixado de UTF-8 como um efeito colateral.

Geralmente acessado através da macro "SvPVbyte".

char* sv_2pvbyte(SV *sv, STRLEN *const lp)

sv_2pvutf8
Retorne um ponteiro para a representação codificada em UTF-8 do SV e defina *lp como seu
comprimento. Pode fazer com que o SV seja atualizado para UTF-8 como efeito colateral.

Geralmente acessado através da macro "SvPVutf8".

char* sv_2pvutf8(SV *sv, STRLEN *const lp)

sv_2pv_flags
Retorna um ponteiro para o valor da string de um SV e define *lp como seu comprimento. Se
flags inclui SV_GMAGIC, faz um mg_get() primeiro. Força sv para uma string se
necessário. Normalmente invocado através da macro "SvPV_flags". "sv_2pv()" e
"sv_2pv_nomg" geralmente acabam aqui também.

char* sv_2pv_flags(SV *const sv, STRLEN *const lp,
sinalizadores const I32)

sv_2uv_flags
Retorna o valor inteiro sem sinal de um SV, fazendo qualquer conversão de string necessária.
Se os sinalizadores incluem SV_GMAGIC, faz um mg_get() primeiro. Normalmente utilizado através do
Macros "SvUV(sv)" e "SvUVx(sv)".

UV sv_2uv_flags(SV *const sv, const I32 sinalizadores)

sv_backoff
Remova qualquer deslocamento de string. Você normalmente deve usar o wrapper de macro "SvOOK_off"
ao invés.

int sv_backoff(SV *const sv)

sv_bless
Abençoa um SV em um pacote especificado. O SV deve ser um RV. O pacote deve
ser designado por seu stash (veja "gv_stashpv()"). A contagem de referência do SV é
não afetado.

SV* sv_bless(SV *const sv, HV *const stash)

sv_catpv
Concatena a string terminada em "NUL" no final da string que está em
o SV. Se o SV tiver o status UTF-8 definido, os bytes anexados devem ser
UTF-8 válido. Manipula a magia 'get', mas não a magia 'set'. Consulte "sv_catpv_mg".

void sv_catpv(SV *const sv, const char* ptr)

sv_catpvf
Processa seus argumentos como "sprintf" e anexa a saída formatada a um SV.
Se os dados anexados contiverem caracteres "amplos" (incluindo, mas não limitado a,
SVs com um PV UTF-8 formatado com %s e caracteres >255 formatados com %c), o
SV original pode ser atualizado para UTF-8. Lida com a magia 'get', mas não 'set'
Magia. Consulte "sv_catpvf_mg". Se o SV original for UTF-8, o padrão deve ser
UTF-8 válido; se o SV original fosse bytes, o padrão também deveria ser.

void sv_catpvf(SV *const sv, const char *const pat,
...)

sv_catpvf_mg
Como "sv_catpvf", mas também lida com magia 'set'.

void sv_catpvf_mg(SV *const sv,
const char *const pat, ...)

sv_catpvn
Concatena a string no final da string que está no SV. O "len"
indica o número de bytes a serem copiados. Se o SV tiver o status UTF-8 definido, o
bytes anexados devem ser UTF-8 válidos. Manipula a magia 'get', mas não a magia 'set'.
Veja "sv_catpvn_mg".

void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)

sv_catpvn_flags
Concatena a string no final da string que está no SV. O "len"
indica o número de bytes a serem copiados.

Por padrão, supõe-se que a string anexada seja UTF-8 válida se o SV tiver o
Conjunto de status UTF-8 e uma string de bytes caso contrário. Pode-se forçar o anexo
string a ser interpretada como UTF-8 fornecendo o sinalizador "SV_CATUTF8" e como bytes
fornecendo o sinalizador "SV_CATBYTES"; o SV ou a string anexada será
atualizado para UTF-8, se necessário.

Se "flags" tiver o bit "SV_SMAGIC" definido, "mg_set" em "dsv" depois se
apropriado. "sv_catpvn" e "sv_catpvn_nomg" são implementados em termos deste
função.

void sv_catpvn_flags(SV *const dstr,
const char *sstr,
const STRLEN lente,
sinalizadores const I32)

sv_catpvs
Como "sv_catpvn", mas leva uma string literal em vez de um par string/comprimento.

void sv_catpvs(SV* sv, const char* s)

sv_catpvs_flags
Como "sv_catpvn_flags", mas recebe uma string literal terminada em "NUL" em vez de uma
par string / comprimento.

void sv_catpvs_flags(SV* sv, const char* s,
bandeiras I32)

sv_catpvs_mg
Como "sv_catpvn_mg", mas leva uma string literal em vez de um par string/comprimento.

void sv_catpvs_mg(SV* sv, const char* s)

sv_catpvs_nomg
Como "sv_catpvn_nomg", mas usa uma string literal em vez de um par string/comprimento.

void sv_catpvs_nomg(SV* sv, const char* s)

sv_catpv_flags
Concatena a string terminada em "NUL" no final da string que está em
o SV. Se o SV tiver o status UTF-8 definido, os bytes anexados devem ser
UTF-8 válido. Se "flags" tiver o bit "SV_SMAGIC" definido, "mg_set" no
SV modificado, se apropriado.

void sv_catpv_flags(SV *dstr, const char *sstr,
sinalizadores const I32)

sv_catpv_mg
Como "sv_catpv", mas também lida com 'set' magic.

void sv_catpv_mg(SV *const sv, const char *const ptr)

sv_catsv
Concatena a string de SV "ssv" no final da string em SV "dsv". Se
"ssv" é nulo, não faz nada; caso contrário, modifica apenas "dsv". Lida com a magia 'get'
em ambos os SVs, mas sem mágica 'definida'. Consulte "sv_catsv_mg" e "sv_catsv_nomg".

vazio sv_catsv(SV *dstr, SV *sstr)

sv_catsv_flags
Concatena a string de SV "ssv" no final da string em SV "dsv". Se
"ssv" é nulo, não faz nada; caso contrário, modifica apenas "dsv". Se "sinalizadores" incluem
O bit "SV_GMAGIC" definido, chamará "mg_get" em ambos os SVs, se apropriado. Se "bandeiras"
incluir "SV_SMAGIC", "mg_set" será chamado no SV modificado posteriormente, se
apropriado. "sv_catsv", "sv_catsv_nomg" e "sv_catsv_mg" são implementados em
termos desta função.

void sv_catsv_flags(SV *const dsv, SV *const ssv,
sinalizadores const I32)

sv_chop Remoção eficiente de caracteres do início do buffer de string.
SvPOK(sv), ou pelo menos SvPOKp(sv), deve ser verdadeiro e o "ptr" deve ser um ponteiro para
em algum lugar dentro do buffer de string. O "ptr" torna-se o primeiro caractere do
corda ajustada. Usa o "hack OOK". No retorno, apenas SvPOK(sv) e SvPOKp(sv)
entre os sinalizadores OK será verdadeiro.

Atenção: após esta função retornar, "ptr" e SvPVX_const(sv) podem não referenciar mais
para o mesmo bloco de dados.

A infeliz semelhança do nome desta função com o "chop" de Perl
operador é estritamente coincidente. Esta função funciona da esquerda; "Picar"
funciona da direita.

void sv_chop(SV *const sv, const char *const ptr)

sv_clear
Limpe um SV: chame quaisquer destruidores, libere qualquer memória usada pelo corpo e libere
o próprio corpo. A cabeça do SV é não liberado, embora seu tipo seja definido como todos os 1s
para que não seja inadvertidamente assumido como vivo durante a destruição global
etc. Esta função só deve ser chamada quando REFCNT for zero. A maior parte do tempo
você desejará chamar "sv_free()" (ou seu wrapper de macro "SvREFCNT_dec").

void sv_clear(SV *const orig_sv)

sv_cmp Compara as strings em dois SVs. Retorna -1, 0 ou 1 indicando se o
string em "sv1" é menor, igual ou maior que a string em "sv2". É
UTF-8 e 'use bytes' cientes, os handles ficam mágicos e coagirão seus argumentos a
cordas, se necessário. Veja também "sv_cmp_locale".

I32 sv_cmp(SV *const sv1, SV *const sv2)

sv_cmp_flags
Compara as strings em dois SVs. Retorna -1, 0 ou 1 indicando se o
string em "sv1" é menor, igual ou maior que a string em "sv2". É
UTF-8 e 'use bytes' estão cientes e forçarão seus argumentos para strings, se necessário. Se
os sinalizadores incluem SV_GMAGIC, ele lida com get magic. Veja também
"sv_cmp_locale_flags".

I32 sv_cmp_flags(SV *const sv1, SV *const sv2,
sinalizadores const U32)

sv_cmp_locale
Compara as cadeias de caracteres em dois SVs com reconhecimento de localidade. É UTF-8 e 'use
bytes' cientes, os handles ficam mágicos e coagirão seus argumentos para strings, se necessário.
Veja também "sv_cmp".

I32 sv_cmp_locale(SV *const sv1, SV *const sv2)

sv_cmp_locale_flags
Compara as cadeias de caracteres em dois SVs com reconhecimento de localidade. É UTF-8 e 'use
bytes' ciente e forçará seus argumentos para strings, se necessário. Se as bandeiras
contém SV_GMAGIC, ele lida com get magic. Veja também "sv_cmp_flags".

I32 sv_cmp_locale_flags(SV *const sv1,
SV *const sv2,
sinalizadores const U32)

sv_collxfrm
Isso chama "sv_collxfrm_flags" com o sinalizador SV_GMAGIC. Veja "sv_collxfrm_flags".

char* sv_collxfrm(SV *const sv, STRLEN *const nxp)

sv_collxfrm_flags
Adicione a magia Collate Transform a um SV se ainda não o tiver. Se as bandeiras
contém SV_GMAGIC, ele lida com get-magic.

Qualquer variável escalar pode carregar a magia PERL_MAGIC_collxfrm que contém o escalar
dados da variável, mas transformados em um formato que uma memória normal
comparação pode ser usada para comparar os dados de acordo com as configurações de localidade.

char* sv_collxfrm_flags(SV *const sv,
STRLEN *const nxp,
I32 const sinalizadores)

sv_copypv_flags
Implementação de sv_copypv e sv_copypv_nomg. As chamadas obtêm bandeiras iff mágicas incluem
SV_GMAGIC.

void sv_copypv_flags(SV *const dsv, SV *const ssv,
sinalizadores const I32)

sv_copypv_nomg
Como sv_copypv, mas não invoca get magic primeiro.

void sv_copypv_nomg(SV *const dsv, SV *const ssv)

sv_dec Auto-decremento do valor no SV, fazendo conversão de string para numérico se
necessário. Manipula a magia 'obter' e a sobrecarga do operador.

void sv_dec(SV *const sv)

sv_dec_nomg
Decremento automático do valor no SV, fazendo conversão de string para numérico se
necessário. Lida com a sobrecarga do operador. Ignora o manuseio da magia 'obter'.

void sv_dec_nomg(SV *const sv)

sv_eq Retorna um booleano indicando se as strings nas duas SVs são idênticas. É
UTF-8 e 'use bytes' cientes, os handles ficam mágicos e coagirão seus argumentos a
cordas, se necessário.

I32 sv_eq(SV* sv1, SV* sv2)

sv_eq_flags
Retorna um booleano indicando se as strings nas duas SVs são idênticas. É
UTF-8 e 'use bytes' conscientes e coagem seus argumentos para strings, se necessário. Se o
sinalizadores incluem SV_GMAGIC, ele lida com get-magic também.

I32 sv_eq_flags(SV* sv1, SV* sv2, const U32 sinalizadores)

sv_force_normal_flags
Desfazer vários tipos de falsificação em um SV, onde falsificação significa "mais do que" uma string: se
o PV é uma string compartilhada, faça uma cópia privada; se formos um árbitro, pare de refingar; E se
somos um glob, rebaixamos para um xpvmg; se formos um escalar copy-on-write, este é o
tempo de gravação quando fazemos a cópia e também é usado localmente; se for uma vstring,
largue a magia vstring. Se "SV_COW_DROP_PV" for definido, um escalar copy-on-write
descarta seu buffer PV (se houver) e se torna SvPOK_off em vez de fazer uma cópia.
(Usado onde este escalar está prestes a ser definido para algum outro valor.) Além disso, o
O parâmetro "flags" é passado para "sv_unref_flags()" ao cancelar o ref.
"sv_force_normal" chama esta função com sinalizadores definidos como 0.

Espera-se que esta função seja usada para sinalizar ao perl que este SV está prestes a ser
escrito, e qualquer contabilidade extra precisa ser cuidada. Portanto,
croaks em valores somente leitura.

void sv_force_normal_flags(SV *const sv,
sinalizadores const U32)

sv_free Decrementa a contagem de referência de um SV e, se cair para zero, chama "sv_clear" para
invocar destruidores e liberar qualquer memória usada pelo corpo; finalmente, desaloque
a própria cabeça do SV. Normalmente chamado por meio de uma macro wrapper "SvREFCNT_dec".

void sv_free(SV *const sv)

sv_gets Obtenha uma linha do filehandle e armazene-a no SV, anexando opcionalmente a
a string atualmente armazenada. Se "append" não for 0, a linha é anexada ao SV
em vez de sobrescrevê-lo. "acrescentar" deve ser definido como o deslocamento de byte que o
string anexada deve começar em no SV (normalmente, "SvCUR(sv)" é um adequado
escolha).

char* sv_gets(SV *const sv, PerlIO *const fp,
I32 anexo)

sv_get_backrefs
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Se o sv for o alvo de uma referência fraca, ele retornará as referências anteriores
estrutura associada ao sv; caso contrário, retorne NULL.

Ao retornar um resultado não nulo, o tipo de retorno é relevante. Se é um
AV então os elementos do AV são os RVs de referência fracos que apontam para este
item. Se for qualquer outro tipo, o próprio item é a referência fraca.

Veja também Perl_sv_add_backref(), Perl_sv_del_backref(), Perl_sv_kill_backrefs()

SV* sv_get_backrefs(SV *const sv)

sv_grow Expande o buffer de caracteres no SV. Se necessário, usa "sv_unref" e
atualiza o SV para "SVt_PV". Retorna um ponteiro para o buffer de caracteres. Use o
Invólucro "SvGROW" em vez disso.

char* sv_grow(SV *const sv, STRLEN newlen)

sv_inc Auto-incremento do valor no SV, fazendo conversão de string para numérico se
necessário. Manipula a magia 'obter' e a sobrecarga do operador.

void sv_inc(SV *const sv)

sv_inc_nomg
Auto-incremento do valor no SV, fazendo string para conversão numérica se
necessário. Lida com a sobrecarga do operador. Ignora o manuseio da magia 'obter'.

void sv_inc_nomg(SV *const sv)

sv_inserir
Insere uma string no deslocamento/comprimento especificado na SV. Semelhante ao
Perl substr () função. Alças ficam mágicas.

void sv_insert(SV *const bigstr, const STRLEN deslocamento,
const STRLEN lente,
const char *const pouco,
const STRLEN pequeno)

sv_insert_flags
O mesmo que "sv_insert", mas os "flags" extras são passados ​​para o "SvPV_force_flags"
isso se aplica a "bigstr".

void sv_insert_flags(SV *const bigstr,
deslocamento STRLEN const,
const STRLEN lente,
const char *const pouco,
const STRLEN pequenolen,
sinalizadores const U32)

sv_isa Retorna um booleano indicando se o SV é abençoado na classe especificada.
Isso não verifica subtipos; use "sv_derived_from" para verificar uma herança
relacionamento.

int sv_isa(SV* sv, const char *const nome)

sv_isobject
Retorna um booleano indicando se o SV é um RV apontando para um objeto abençoado.
Se o SV não for um RV ou se o objeto não for abençoado, isso retornará
falsa

int sv_isobject(SV* sv)

sv_len Retorna o comprimento da string no SV. Lida com magia e tipo de coerção e
define o sinalizador UTF8 apropriadamente. Veja também "SvCUR", que dá acesso bruto ao
slot xpv_cur.

STRLEN sv_len(SV *const sv)

sv_len_utf8
Retorna o número de caracteres na string em um SV, contando os bytes UTF-8 largos
como um único personagem. Lida com magia e coerção de tipo.

STRLEN sv_len_utf8(SV *const sv)

sv_magic
Adiciona magia a um SV. Primeiro atualiza "sv" para o tipo "SVt_PVMG" se necessário, então
adiciona um novo item mágico do tipo "como" ao topo da lista mágica.

Consulte "sv_magicext" (que "sv_magic" agora chama) para obter uma descrição do manuseio
dos argumentos "name" e "namlen".

Você precisa usar "sv_magicext" para adicionar magia aos SVs SvREADONLY e também para adicionar mais
mais de uma instância do mesmo 'como'.

void sv_magic(SV *const sv, SV *const obj,
const int como, const char *const nome,
const I32 nome)

sv_magicext
Adiciona magia a um SV, atualizando-o se necessário. Aplica o vtable fornecido e
retorna um ponteiro para a mágica adicionada.

Observe que "sv_magicext" permitirá coisas que "sv_magic" não permitirá. Dentro
em particular, você pode adicionar magia aos SVs SvREADONLY e adicionar mais de uma instância de
o mesmo 'como'.

Se "namlen" for maior que zero, então um "savepvn" cópia de "nome" é armazenado, se
"namlen" é zero, então "name" é armazenado como está e - como outro caso especial - se
"(nome && namlen == HEf_SVKEY)" então "nome" é assumido como contendo um "SV*" e é
armazenado como está com seu REFCNT incrementado.

(Isso agora é usado como uma sub-rotina por "sv_magic".)

MAGIC * sv_magicext(SV *const sv, SV *const obj,
const int como,
const MGVTBL *const vtbl,
const char *const nome,
const I32 nome)

sv_mortalcopy
Cria um novo SV que é uma cópia do SV original (usando "sv_setsv"). O novo
SV é marcado como mortal. Ele será destruído "em breve", seja por uma chamada explícita
para FREETMPS ou por uma chamada implícita em locais como limites de instrução. Ver
também "sv_newmortal" e "sv_2mortal".

SV* sv_mortalcopy(SV *const oldsv)

sv_newmortal
Cria um novo SV nulo que é mortal. A contagem de referência do SV é definida como 1.
Ele será destruído "em breve", seja por uma chamada explícita ao FREETMPS ou por um
chamada implícita em locais como limites de instrução. Veja também "sv_mortalcopy"
e "sv_2mortal".

SV * sv_newmortal ()

sv_newref
Incrementa a contagem de referência de um SV. Em vez disso, use o wrapper "SvREFCNT_inc()".

SV* sv_newref(SV *const sv)

sv_pos_b2u
Converte o valor apontado por offsetp de uma contagem de bytes desde o início de
a string, para uma contagem do número equivalente de caracteres UTF-8. Lida com magia e
tipo coerção.

Use "sv_pos_b2u_flags" de preferência, que lida corretamente com strings maiores que
2Gb.

void sv_pos_b2u(SV *const sv, I32 *const offsetp)

sv_pos_b2u_flags
Converte o deslocamento de uma contagem de bytes desde o início da string em uma contagem
do número equivalente de caracteres UTF-8. Lida com coerção de tipo. bandeiras passou
para "SvPV_flags" e geralmente deve ser "SV_GMAGIC|SV_CONST_RETURN" para manipular
magia.

STRLEN sv_pos_b2u_flags(SV *const sv,
STRLEN const offset, sinalizadores U32)

sv_pos_u2b
Converte o valor apontado por offsetp de uma contagem de caracteres UTF-8 do
início da string, para uma contagem do número equivalente de bytes; se lenp não for
zero, faz o mesmo com lenp, mas desta vez partindo do offset, ao invés
do que no início da string. Lida com magia e coerção de tipo.

Use "sv_pos_u2b_flags" de preferência, que lida corretamente com strings maiores que
2Gb.

void sv_pos_u2b(SV *const sv, I32 *const offsetp,
I32 *constlenp)

sv_pos_u2b_flags
Converte o deslocamento de uma contagem de caracteres UTF-8 desde o início da string em um
contagem do número equivalente de bytes; se lenp for diferente de zero, faz o mesmo para
lenp, mas desta vez a partir do deslocamento, em vez do início do
corda. Lida com coerção de tipo. bandeiras é passado para "SvPV_flags", e geralmente
deve ser "SV_GMAGIC|SV_CONST_RETURN" para lidar com a magia.

STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset,
STRLEN *const lenp, sinalizadores U32)

sv_pvbyten_force
O back-end para a macro "SvPVbytex_force". Sempre use a macro em vez disso.

char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)

sv_pvn_force
Obtenha uma sequência sensata do SV de alguma forma. Uma implementação privada do
Macro "SvPV_force" para compiladores que não conseguem lidar com expressões de macro complexas.
Sempre use a macro em vez disso.

char* sv_pvn_force(SV* sv, STRLEN* lp)

sv_pvn_force_flags
Obtenha uma sequência sensata do SV de alguma forma. Se "flags" tiver o bit "SV_GMAGIC" definido,
irá "mg_get" em "sv" se apropriado, senão não. "sv_pvn_force" e
"sv_pvn_force_nomg" são implementados em termos desta função. Você normalmente quer
para usar as várias macros wrapper: consulte "SvPV_force" e "SvPV_force_nomg"

char* sv_pvn_force_flags(SV *const sv,
STRLEN *const lp,
sinalizadores const I32)

sv_pvutf8n_force
O back-end para a macro "SvPVutf8x_force". Sempre use a macro em vez disso.

char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)

sv_reftype
Retorna uma string que descreve o que o SV é uma referência.

const char* sv_reftype(const SV *const sv, const int ob)

sv_replace
Faça do primeiro argumento uma cópia do segundo e exclua o original. o
O SV de destino assume fisicamente a propriedade do corpo do SV de origem e
herda suas bandeiras; no entanto, o alvo mantém qualquer magia que possua, e qualquer magia em
a fonte é descartada. Observe que esta é uma cópia SV bastante especializada
Operação; na maioria das vezes você vai querer usar "sv_setsv" ou uma de suas muitas macros
termina em frente.

void sv_replace(SV *const sv, SV *const nsv)

sv_reset
Implementação subjacente para a função Perl "redefinir". Observe que o nível perl
A função está vagamente obsoleta.

void sv_reset(const char* s, HV *const stash)

sv_rvweaken
Enfraquecer uma referência: definir o sinalizador "SvWEAKREF" neste RV; dar o referido SV
mágica "PERL_MAGIC_backref" se ainda não tiver; e enviar uma referência anterior a isso
RV na matriz de referências anteriores associadas a essa mágica. Se o RV for
mágico, set magic será chamado depois que o RV for limpo.

SV* sv_rvweaken(SV *const sv)

sv_setiv
Copia um número inteiro no SV fornecido, atualizando primeiro, se necessário. não
lidar com a magia 'set'. Veja também "sv_setiv_mg".

void sv_setiv(SV *const sv, const IV num)

sv_setiv_mg
Como "sv_setiv", mas também lida com a magia 'set'.

void sv_setiv_mg(SV *const sv, const IV i)

sv_setnv
Copia um duplo no SV fornecido, atualizando primeiro, se necessário. não lida
'definir' magia. Consulte também "sv_setnv_mg".

void sv_setnv(SV *const sv, const NV num)

sv_setnv_mg
Como "sv_setnv", mas também lida com a magia 'set'.

void sv_setnv_mg(SV *const sv, const NV num)

sv_setpv
Copia uma string em um SV. A string deve ser terminada com um caractere "NUL".
Não lida com magia 'set'. Consulte "sv_setpv_mg".

void sv_setpv(SV *const sv, const char *const ptr)

sv_setpvf
Funciona como "sv_catpvf", mas copia o texto no SV em vez de anexá-lo.
Não lida com magia 'set'. Consulte "sv_setpvf_mg".

void sv_setpvf(SV *const sv, const char *const pat,
...)

sv_setpvf_mg
Como "sv_setpvf", mas também lida com a magia 'set'.

void sv_setpvf_mg(SV *const sv,
const char *const pat, ...)

sv_setpviv
Copia um inteiro no SV fornecido, também atualizando seu valor de string. não
lidar com a magia 'set'. Consulte "sv_setpviv_mg".

void sv_setpviv(SV *const sv, const IV num)

sv_setpviv_mg
Como "sv_setpviv", mas também manipula a magia 'set'.

void sv_setpviv_mg(SV *const sv, const IV iv)

sv_setpvn
Copia uma string (possivelmente contendo caracteres "NUL" incorporados) em um SV. o
O parâmetro "len" indica o número de bytes a serem copiados. Se o argumento "ptr"
for NULL, o SV ficará indefinido. Não lida com magia 'set'. Ver
"sv_setpvn_mg".

void sv_setpvn(SV *const sv, const char *const ptr,
const STRLEN len)

sv_setpvn_mg
Como "sv_setpvn", mas também lida com a magia 'set'.

void sv_setpvn_mg(SV *const sv,
const char * const ptr,
const STRLEN len)

sv_setpvs
Como "sv_setpvn", mas usa uma string literal em vez de um par string/comprimento.

void sv_setpvs(SV* sv, const char* s)

sv_setpvs_mg
Como "sv_setpvn_mg", mas usa uma string literal em vez de um par string/comprimento.

void sv_setpvs_mg(SV* sv, const char* s)

sv_setpv_mg
Como "sv_setpv", mas também lida com a magia 'set'.

void sv_setpv_mg(SV *const sv, const char *const ptr)

sv_setref_iv
Copia um número inteiro em um novo SV, opcionalmente abençoando o SV. O argumento "rv"
será atualizado para um RV. Esse RV será modificado para apontar para o novo SV. o
O argumento "classname" indica o pacote para a bênção. Defina "classname" como
"NULL" para evitar a bênção. O novo SV terá uma contagem de referência de 1 e
o RV será devolvido.

SV* sv_setref_iv(SV *const rv,
const char *const nome da classe,
constante IV iv)

sv_setref_nv
Copia um duplo em um novo SV, opcionalmente abençoando o SV. O argumento "rv" irá
ser atualizado para um RV. Esse RV será modificado para apontar para o novo SV. o
O argumento "classname" indica o pacote para a bênção. Defina "classname" como
"NULL" para evitar a bênção. O novo SV terá uma contagem de referência de 1 e
o RV será devolvido.

SV* sv_setref_nv(SV *const rv,
const char *const nome da classe,
const NV nv)

sv_setref_pv
Copia um ponteiro em um novo SV, abençoando opcionalmente o SV. O argumento "rv"
será atualizado para um RV. Esse RV será modificado para apontar para o novo SV. Se
o argumento "pv" é NULL então "PL_sv_undef" será colocado no SV. o
O argumento "classname" indica o pacote para a bênção. Defina "classname" como
"NULL" para evitar a bênção. O novo SV terá uma contagem de referência de 1 e
o RV será devolvido.

Não use com outros tipos Perl como HV, AV, SV, CV, porque esses objetos
será corrompido pelo processo de cópia do ponteiro.

Observe que "sv_setref_pvn" copia a string enquanto este copia o ponteiro.

SV* sv_setref_pv(SV *const rv,
const char *const nome da classe,
vazio *const pv)

sv_setref_pvn
Copia uma string em um novo SV, opcionalmente abençoando o SV. O comprimento do
string deve ser especificada com "n". O argumento "rv" será atualizado para um RV.
Esse RV será modificado para apontar para o novo SV. O argumento "classname"
indica o pacote para a bênção. Defina "classname" como "NULL" para evitar o
bênção. O novo SV terá uma contagem de referência de 1 e o RV será
devolvida.

Observe que "sv_setref_pv" copia o ponteiro enquanto este copia a string.

SV* sv_setref_pvn(SV *const rv,
const char *const nome da classe,
const char * const pv,
const STRLENn)

sv_setref_pvs
Como "sv_setref_pvn", mas usa uma string literal em vez de um par string/comprimento.

SV * sv_setref_pvs(const char*s)

sv_setref_uv
Copia um inteiro não assinado em um novo SV, opcionalmente abençoando o SV. O "RV"
argumento será atualizado para um RV. Esse RV será modificado para apontar para o novo
SV. O argumento "classname" indica o pacote para a bênção. Definir
"classname" para "NULL" para evitar a bênção. O novo SV terá uma referência
contagem de 1, e o RV será devolvido.

SV* sv_setref_uv(SV *const rv,
const char *const nome da classe,
const UV UV)

sv_setsv
Copia o conteúdo do SV de origem "ssv" para o SV de destino "dsv". o
source SV pode ser destruído se for mortal, então não use esta função se o
O SV de origem precisa ser reutilizado. Não lida com a magia 'definida' no SV de destino.
Chama a magia 'obter' no SV de origem. Grosso modo, ele executa uma cópia por valor,
obliterando qualquer conteúdo anterior do destino.

Você provavelmente deseja usar um dos sortimentos de wrappers, como "SvSetSV",
"SvSetSV_nosteal", "SvSetMagicSV" e "SvSetMagicSV_nosteal".

vazio sv_setsv(SV *dstr, SV *sstr)

sv_setsv_flags
Copia o conteúdo do SV de origem "ssv" para o SV de destino "dsv". o
source SV pode ser destruído se for mortal, então não use esta função se o
O SV de origem precisa ser reutilizado. Não lida com magia 'set'. Falando vagamente, é
executa uma cópia por valor, eliminando qualquer conteúdo anterior do destino.
Se o parâmetro "flags" tiver o bit "SV_GMAGIC" definido, será "mg_get" em "ssv" se
apropriado, senão não. Se o parâmetro "flags" tiver o bit "SV_NOSTEAL" definido, então
os buffers de temps não serão roubados. e "sv_setsv_nomg" são
implementado em termos desta função.

Você provavelmente deseja usar um dos sortimentos de wrappers, como "SvSetSV",
"SvSetSV_nosteal", "SvSetMagicSV" e "SvSetMagicSV_nosteal".

Esta é a função primária para copiar escalares, e a maioria das outras funções de cópia
funções e macros usam isso por baixo.

void sv_setsv_flags(SV *dstr, SV *sstr,
sinalizadores const I32)

sv_setsv_mg
Como "sv_setsv", mas também lida com a magia 'set'.

void sv_setsv_mg(SV *const dstr, SV *const sstr)

sv_setuv
Copia um inteiro sem sinal no SV fornecido, atualizando primeiro, se necessário. Faz
não lidar com a magia 'set'. Veja também "sv_setuv_mg".

void sv_setuv(SV *const sv, const UV num)

sv_setuv_mg
Como "sv_setuv", mas também lida com magia de 'set'.

void sv_setuv_mg(SV *const sv, const UV u)

sv_tainted
Teste um SV quanto à contaminação. Use "SvTAINTED" em vez disso.

bool sv_tainted(SV *const sv)

sv_true Retorna verdadeiro se o SV tiver um valor verdadeiro pelas regras do Perl. Use a macro "SvTRUE"
em vez disso, que pode chamar "sv_true()" ou usar uma versão in-line.

I32 sv_true(SV *const sv)

sv_unmagic
Remove toda a magia do tipo "type" de um SV.

int sv_unmagic(SV *const sv, const tipo int)

sv_unmagicext
Remove toda a magia do tipo "type" com o "vtbl" especificado de um SV.

int sv_unmagicext(SV *const sv, const tipo int,
MGVTBL *vtbl)

sv_unref_flags
Desativa o status de RV do SV e diminui a contagem de referência de tudo o que foi
sendo referenciado pelo RV. Isso quase pode ser pensado como uma inversão de
"novoSVrv". O argumento "cflags" pode conter "SV_IMMEDIATE_UNREF" para forçar o
contagem de referência a ser diminuída (caso contrário, a diminuição estará condicionada
a contagem de referência é diferente de uma ou a referência é somente leitura
SV). Consulte "SvROK_off".

void sv_unref_flags(SV *const ref, const sinalizadores U32)

sv_untaint
Limpar um SV. Use "SvTAINTED_off" em vez disso.

void sv_untaint(SV *const sv)

sv_upgrade
Atualize um SV para um formato mais complexo. Geralmente adiciona um novo tipo de corpo ao SV,
em seguida, copia o máximo de informações possível do corpo antigo. Ele coaxa
se o SV já estiver em formato mais complexo do que o solicitado. Você geralmente quer
use o wrapper de macro "SvUPGRADE", que verifica o tipo antes de chamar
"sv_upgrade" e, portanto, não coaxa. Veja também "svtype".

void sv_upgrade(SV *const sv, svtype novo_type)

sv_usepvn_flags
Diz a um SV para usar "ptr" para encontrar o valor da string. Normalmente a string é armazenada
dentro do SV, mas sv_usepvn permite que o SV use uma string externa. O "ptr"
deve apontar para a memória alocada pelo Newx. Deve ser o início de uma
Bloco de memória recém-editado, e não um ponteiro para o meio dele (cuidado com OOK e
copy-on-write) e não ser de um alocador de memória não Newx como "malloc". O
o comprimento da string, "len", deve ser fornecido. Por padrão, esta função irá "Renovar"
(ou seja, realocar, mover) a memória apontada por "ptr", de modo que o ponteiro não deve ser
liberado ou usado pelo programador após entregá-lo ao sv_usepvn, e nenhum deles deveria
quaisquer ponteiros "atrás" desse ponteiro (por exemplo, ptr + 1) serão usados.

Se "flags" & SV_SMAGIC forem verdadeiros, chamará SvSETMAGIC. Se "sinalizadores" &
SV_HAS_TRAILING_NUL é verdadeiro, então "ptr[len]" deve ser "NUL" e o realloc será
ser ignorado (ou seja, o buffer é na verdade pelo menos 1 byte maior que "len", e
já atende aos requisitos para armazenamento em "SvPVX").

void sv_usepvn_flags(SV *const sv, char* ptr,
const STRLEN lente,
sinalizadores const U32)

sv_utf8_decode
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Se o PV do SV for uma sequência de octetos em UTF-8 e contiver um byte múltiplo
caractere, o sinalizador "SvUTF8" é ativado para que se pareça com um caractere. Se
o PV contém apenas caracteres de byte único, o sinalizador "SvUTF8" permanece desativado. Verificações
PV para validade e retorna falso se o PV for UTF-8 inválido.

bool sv_utf8_decode(SV *const sv)

sv_utf8_downgrade
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Tenta converter o PV de um SV de caracteres para bytes. Se o PV contiver
um caractere que não cabe em um byte, esta conversão falhará; nesse caso,
retorna falso ou, se "fail_ok" não for verdadeiro, grasna.

Esta não é uma interface Unicode de uso geral para codificação de bytes: use o Encode
extensão para isso.

bool sv_utf8_downgrade(SV *const sv,
const bool fail_ok)

sv_utf8_encode
Converte o PV de um SV em UTF-8, mas depois desativa o sinalizador "SvUTF8" para que
parece octetos novamente.

void sv_utf8_encode(SV *const sv)

sv_utf8_upgrade
Converte o PV de um SV em seu formato codificado em UTF-8. Força o SV para o formato string
se ainda não estiver. Será "mg_get" em "sv" se apropriado. Sempre define o
Sinalizador SvUTF8 para evitar futuras verificações de validade, mesmo que toda a string seja a mesma
em UTF-8 como não. Retorna o número de bytes na string convertida

Esta não é uma codificação de bytes de uso geral para interface Unicode: use o Encode
extensão para isso.

STRLEN sv_utf8_upgrade(SV *sv)

sv_utf8_upgrade_flags
Converte o PV de um SV em seu formato codificado em UTF-8. Força o SV para o formato string
se ainda não estiver. Sempre define o sinalizador SvUTF8 para evitar futuras verificações de validade
mesmo que todos os bytes sejam invariantes em UTF-8. Se "flags" tiver o bit "SV_GMAGIC" definido,
irá "mg_get" em "sv" se apropriado, caso contrário não.

Se "flags" tiver SV_FORCE_UTF8_UPGRADE definido, esta função assume que o PV irá
expand quando convertido para UTF-8 e ignora o trabalho extra de verificação disso.
Normalmente, esse sinalizador é usado por uma rotina que já analisou a string e
encontrou tais personagens e repassa essas informações para que o trabalho não
tem que ser repetido.

Retorna o número de bytes na string convertida.

Esta não é uma codificação de bytes de uso geral para interface Unicode: use o Encode
extensão para isso.

STRLEN sv_utf8_upgrade_flags(SV *const sv,
sinalizadores const I32)

sv_utf8_upgrade_flags_grow
Como sv_utf8_upgrade_flags, mas possui um parâmetro adicional "extra", que é o
número de bytes não utilizados, a sequência de 'sv' tem garantia de estar livre após
retornar. Isto permite que o chamador reserve espaço extra que pretende preencher, para
evite crescimentos extras.

"sv_utf8_upgrade", "sv_utf8_upgrade_nomg" e "sv_utf8_upgrade_flags" são
implementado em termos desta função.

Retorna o número de bytes na string convertida (sem incluir os sobressalentes).

STRLEN sv_utf8_upgrade_flags_grow(SV *const sv,
sinalizadores const I32,
ESTRELA extra)

sv_utf8_upgrade_nomg
Como sv_utf8_upgrade, mas não faz mágica em "sv".

STRLEN sv_utf8_upgrade_nomg(SV *sv)

sv_vcatpvf
Processa seus argumentos como "vsprintf" e anexa a saída formatada a um SV.
Não lida com magia 'definida'. Consulte "sv_vcatpvf_mg".

Geralmente usado através de seu frontend "sv_catpvf".

void sv_vcatpvf(SV *const sv, const char *const pat,
va_list *const argumentos)

sv_vcatpvfn
void sv_vcatpvfn(SV *const sv, const char *const pat,
const STRLEN patlen,
va_list *const argumentos,
SV **const svargs, const I32 svmax,
bool *const talvez_contaminado)

sv_vcatpvfn_flags
Processa seus argumentos como "vsprintf" e anexa a saída formatada a um SV.
Usa uma matriz de SVs se a lista de argumentos de variáveis ​​de estilo C estiver faltando (NULL).
Ao executar com verificações de taint ativadas, indica via "maybe_tainted" se os resultados
não são confiáveis ​​(geralmente devido ao uso de localidades).

Se chamadas como "sv_vcatpvfn" ou os sinalizadores incluírem "SV_GMAGIC", as chamadas serão mágicas.

Geralmente usado através de um de seus frontends "sv_vcatpvf" e "sv_vcatpvf_mg".

void sv_vcatpvfn_flags(SV *const sv,
const char *const pat,
const STRLEN patlen,
va_list *const argumentos,
SV **const svargs,
const I32 svmax,
bool *const talvez_contaminado,
sinalizadores const U32)

sv_vcatpvf_mg
Como "sv_vcatpvf", mas também lida com magia 'set'.

Geralmente usado através de seu frontend "sv_catpvf_mg".

void sv_vcatpvf_mg(SV *const sv,
const char *const pat,
va_list *const argumentos)

sv_vsetpvf
Funciona como "sv_vcatpvf", mas copia o texto no SV em vez de anexá-lo.
Não lida com magia 'definida'. Consulte "sv_vsetpvf_mg".

Geralmente usado através de seu frontend "sv_setpvf".

void sv_vsetpvf(SV *const sv, const char *const pat,
va_list *const argumentos)

sv_vsetpvfn
Funciona como "sv_vcatpvfn", mas copia o texto no SV em vez de anexá-lo.

Geralmente usado através de um de seus frontends "sv_vsetpvf" e "sv_vsetpvf_mg".

void sv_vsetpvfn(SV *const sv, const char *const pat,
const STRLEN patlen,
va_list *const argumentos,
SV **const svargs, const I32 svmax,
bool *const talvez_contaminado)

sv_vsetpvf_mg
Como "sv_vsetpvf", mas também lida com magia 'set'.

Geralmente usado através de seu frontend "sv_setpvf_mg".

void sv_vsetpvf_mg(SV *const sv,
const char *const pat,
va_list *const argumentos)

Unicode Suporte

"Suporte Unicode" em perlguts contém uma introdução a esta API.

Consulte também "Classificação de caracteres" e "Alteração de caracteres entre maiúsculas e minúsculas". Várias funções
fora desta seção também funcionam especialmente com Unicode. Procure a string "utf8" em
esse documento.

bytes_cmp_utf8
Compara a sequência de caracteres (armazenados como octetos) em "b", "blen" com o
sequência de caracteres (armazenada como UTF-8) em "u", "ulen". Retorna 0 se forem
igual, -1 ou -2 se a primeira string for menor que a segunda string, +1 ou +2 se
a primeira string é maior que a segunda string.

-1 ou +1 será retornado se a string mais curta for idêntica ao início do
corda mais longa. -2 ou +2 é retornado se houver diferença entre os caracteres
dentro das cordas.

int bytes_cmp_utf8(const U8 *b, STRLEN blen,
const U8 *u, STRLEN ulen)

bytes_de_utf8
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Converte uma string "s" de comprimento "len" de UTF-8 em codificação de byte nativa.
Ao contrário de "utf8_to_bytes", mas como "bytes_to_utf8", retorna um ponteiro para o recém-
string criada e atualiza "len" para conter o novo comprimento. Retorna o original
string se nenhuma conversão ocorrer, "len" permanece inalterado. Não faça nada se "is_utf8"
aponta para 0. Define "is_utf8" como 0 se "s" for convertido ou consistir inteiramente em
caracteres que são invariantes em utf8 (ou seja, US-ASCII em máquinas não-EBCDIC).

U8* bytes_from_utf8(const U8 *s, STRLEN *len,
bool *é_utf8)

bytes_to_utf8
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Converte uma string "s" de comprimento "len" bytes da codificação nativa em UTF-8.
Retorna um ponteiro para a string recém-criada e define "len" para refletir a nova
comprimento em bytes.

Um caractere "NUL" será escrito após o final da string.

Se você deseja converter para UTF-8 a partir de codificações diferentes da nativa (Latin1 ou
EBCDIC), consulte "sv_recode_to_utf8"().

U8* bytes_to_utf8(const U8 *s, STRLEN *len)

DO_UTF8 Retorna um bool informando se o PV em "sv" deve ou não ser tratado como sendo
codificado em UTF-8.

Você deve usar isso depois de uma chamada para "SvPV()" ou uma de suas variantes, caso alguma
a chamada para sobrecarga de string atualiza o sinalizador de codificação UTF-8 interno.

bool DO_UTF8(SV*sv)

dobrarEQ_utf8
Retorna verdadeiro se as partes iniciais das strings "s1" e "s2" (uma ou ambas
dos quais podem estar em UTF-8) são iguais sem distinção entre maiúsculas e minúsculas; falso caso contrário. Como
O avanço nas strings para comparação é determinado por outros parâmetros de entrada.

Se "u1" for verdadeiro, presume-se que a string "s1" esteja em Unicode codificado em UTF-8;
caso contrário, presume-se que esteja na codificação nativa de 8 bits. Correspondentemente para "u2"
em relação a "s2".

Se o comprimento do byte "l1" for diferente de zero, indica a que distância em "s1" verificar a dobra
igualdade. Ou seja, "s1"+"l1" será utilizado como meta a ser alcançada. A varredura
não será considerado uma partida a menos que o objetivo seja alcançado e a digitalização
não continuará além desse objetivo. Correspondentemente para "l2" em relação a "s2".

Se "pe1" não for NULL e o ponteiro para o qual ele aponta não for NULL, esse ponteiro será
considerado um ponteiro final para a posição 1 byte após o ponto máximo em "s1"
além do qual a digitalização não continuará sob nenhuma circunstância. (Essa rotina
assume que as strings de entrada codificadas em UTF-8 não estão malformadas; entrada malformada pode
fazer com que ele leia além de "pe1"). Isto significa que se ambos "l1" e "pe1" forem
especificado e "pe1" for menor que "s1"+"l1", a correspondência nunca será bem-sucedida
porque nunca pode chegar tão longe quanto o seu objectivo (e de facto é contrariado).
Correspondentemente para "pe2" em relação a "s2".

Pelo menos um dos "s1" e "s2" deve ter um objetivo (pelo menos um dos "l1" e "l2" deve
ser diferente de zero) e se ambos o fizerem, ambos deverão ser alcançados para uma correspondência bem-sucedida.
Além disso, se a dobra de um personagem tiver vários caracteres, todos eles deverão ser
combinado (veja a referência tr21 abaixo para 'dobrar').

Após uma correspondência bem-sucedida, se "pe1" não for NULL, será definido para apontar para o
começo do Próximo caractere de "s1" além do que foi correspondido. Correspondentemente
para "pe2" e "s2".

Para não diferenciar maiúsculas de minúsculas, o "casefolding" do Unicode é usado em vez de
colocar ambos os caracteres em maiúsculas/minúsculas, consulte
<http://www.unicode.org/unicode/reports/tr21/> (Mapeamentos de Caso).

I32 foldEQ_utf8(const char *s1, char **pe1, UV l1,
bool u1, const char *s2, char **pe2,
UV l2, bool u2)

éUTF8_CHAR
Retorna o número de bytes começando em "s" que formam um UTF-8 legal (ou UTF-
EBCDIC) caractere codificado, não procurando além de "e - s" bytes em "s".
Retorna 0 se a sequência começando em "s" até "e - 1" não for UTF-8 bem formada

Observe que um caractere INVARIANT (isto é, ASCII em máquinas não-EBCDIC) é um caractere válido.
Caractere UTF-8.

STRLEN isUTF8_CHAR(const U8 *s, const U8 *e)

is_ascii_string
Este é um sinônimo com nome enganoso para "is_invariant_string". Em ASCII
plataformas, o nome não é enganoso: os caracteres do intervalo ASCII são exatamente os
Invariantes UTF-8. Mas as máquinas EBCDIC têm mais invariantes do que apenas o ASCII
caracteres, então "is_invariant_string" é o preferido.

bool is_ascii_string(const U8 *s, STRLEN len)

is_invariant_string
Retorna verdadeiro se os primeiros bytes "len" da string "s" forem iguais independentemente
da codificação UTF-8 da string (ou codificação UTF-EBCDIC em máquinas EBCDIC).
Isto é, se eles forem invariantes ao UTF-8. Em máquinas ASCII, todos os caracteres ASCII
caracteres e apenas os caracteres ASCII se enquadram nesta definição. Nas máquinas EBCDIC,
os caracteres do intervalo ASCII são invariáveis, mas também o são os controles C1 e
"\c?" (que não está na faixa ASCII no EBCDIC).

Se "len" for 0, será calculado usando strlen(s), (o que significa que se você usar este
opção, que "s" não pode ter caracteres "NUL" incorporados e deve ter um
terminando o byte "NUL").

Consulte também "is_utf8_string"(), "is_utf8_string_loclen"() e
"is_utf8_string_loc"().

bool is_invariant_string(const U8 *s, STRLEN len)

is_utf8_string
Retorna verdadeiro se os primeiros bytes "len" da string "s" formarem uma string UTF-8 válida,
falso caso contrário. Se "len" for 0, será calculado usando strlen(s) (que
significa que se você usar esta opção, "s" não pode ter caracteres "NUL" incorporados e
tem que ter um byte de terminação "NUL"). Observe que todos os caracteres são ASCII
constituem 'uma string UTF-8 válida'.

Consulte também "is_invariant_string"(), "is_utf8_string_loclen"() e
"is_utf8_string_loc"().

bool is_utf8_string(const U8 *s, STRLEN len)

is_utf8_string_loc
Como "is_utf8_string", mas armazena o local da falha (no caso de
"utf8ness failed") ou o local "s"+"len" (no caso de "utf8ness Success")
no "ep".

Veja também "is_utf8_string_loclen"() e "is_utf8_string"().

bool is_utf8_string_loc(const U8 *s, STRLEN len,
const U8 **ep)

is_utf8_string_loclen
Como "is_utf8_string"() mas armazena a localização da falha (no caso de
"utf8ness failed") ou o local "s"+"len" (no caso de "utf8ness Success")
no "ep" e o número de caracteres codificados em UTF-8 no "el".

Veja também "is_utf8_string_loc"() e "is_utf8_string"().

bool is_utf8_string_loclen(const U8 *s, STRLEN len,
const U8 **ep, STRLEN *el)

pv_uni_display
Construa para o escalar "dsv" uma versão exibível da string "spv", comprimento "len",
a versão exibível tendo no máximo "pvlim" bytes de comprimento (se for maior, o resto é
truncado e "..." será anexado).

O argumento "flags" pode ter UNI_DISPLAY_ISPRINT definido para exibir éPRINT()capaz
caracteres como eles próprios, UNI_DISPLAY_BACKSLASH para exibir o \\[nrfta\\] como o
versões com barra invertida (como '\n') (UNI_DISPLAY_BACKSLASH é preferível a
UNI_DISPLAY_ISPRINT para \\). UNI_DISPLAY_QQ (e seu alias UNI_DISPLAY_REGEX)
tenha UNI_DISPLAY_BACKSLASH e UNI_DISPLAY_ISPRINT ativados.

O ponteiro para o PV do "dsv" é retornado.

Consulte também "sv_uni_display".

char* pv_uni_display(SV *dsv, const U8 *spv,
STRLEN len, STRLEN pvlim,
Sinalizadores UV)

sv_cat_decode
A codificação é considerada um objeto Encode, o PV do ssv é considerado
octetos nessa codificação e decodificação a entrada começa na posição que (PV
+ *deslocamento) apontado. O dsv será concatenado com a string UTF-8 decodificada de
ssv. A decodificação terminará quando a string tstr aparecer na saída de decodificação ou
a entrada termina no PV do ssv. O valor que os pontos de deslocamento serão
modificado para a última posição de entrada no ssv.

Retorna TRUE se o terminador foi encontrado, caso contrário retorna FALSE.

bool sv_cat_decode(SV* dsv, SV *codificação, SV *ssv,
int *offset, char* tstr, int tlen)

sv_recode_to_utf8
A codificação é assumida como um objeto Encode, na entrada o PV do sv é
assumidos como octetos nessa codificação, e o sv será convertido em Unicode
(e UTF-8).

Se o sv já for UTF-8 (ou se não for POK), ou se a codificação não for um
referência, nada é feito ao sv. Se a codificação não for "Encode::XS"
Codificando objeto, coisas ruins acontecerão. (Ver lib/encoding.pm e Codificar.)

O PV do sv é retornado.

char* sv_recode_to_utf8(SV* sv, SV *codificação)

sv_uni_display
Construa para o escalar "dsv" uma versão exibível do escalar "sv", o
versão exibível com no máximo "pvlim" bytes de comprimento (se for maior, o resto é
truncado e "..." será anexado).

O argumento "flags" é como em "pv_uni_display"().

O ponteiro para o PV do "dsv" é retornado.

char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim,
Sinalizadores UV)

to_utf8_case
"p" contém o ponteiro para a string UTF-8 que codifica o caractere que está sendo
convertido. Esta rotina pressupõe que o caractere em “p” esteja bem formado.

"ustrp" é um ponteiro para o buffer de caracteres no qual colocar o resultado da conversão.
"lenp" é um ponteiro para a duração do resultado.

"swashp" é um ponteiro para o swash a ser usado.

Os mapeamentos especial e normal são armazenados em lib/unicore/To/Foo.pl e
carregado por SWASHNEW, usando lib/utf8_heavy.pl. "especial" (normalmente, mas nem sempre,
um mapeamento multicaractere), é tentado primeiro.

"especial" é uma string, normalmente "NULL" ou "". "NULL" significa não usar nenhum
mapeamentos; "" significa usar os mapeamentos especiais. Valores diferentes desses dois são
tratado como o nome do hash que contém os mapeamentos especiais, como
"utf8::ToSpecLower".

"normal" é uma string como "ToLower", que significa o swash %utf8::ToLower.

UV to_utf8_case(const U8 *p, U8* ustrp,
STRLEN *lenp, SV **swashp,
const char *normal,
const char *especial)

to_utf8_fold
Em vez disso, use "toFOLD_utf8".

UV to_utf8_fold(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_lower
Em vez disso, use "toLOWER_utf8".

UV to_utf8_lower(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_title
Em vez disso, use "toTITLE_utf8".

UV to_utf8_title(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_upper
Em vez disso, use "toUPPER_utf8".

UV to_utf8_upper(const U8 *p, U8* ustrp,
STRLEN *lenp)

utf8n_to_uvchr
ESTA FUNÇÃO DEVE SER UTILIZADA APENAS EM CIRCUNSTÂNCIAS MUITO ESPECIALIZADAS. A maior parte do código
deve usar "utf8_to_uvchr_buf"() em vez de chamar isso diretamente.

Rotina de decodificação UTF-8 de nível inferior. Retorna o valor do ponto de código nativo do
primeiro caractere na string "s", que se presume estar em UTF-8 (ou UTF-EBCDIC)
codificação e não mais que bytes "curlen"; *retlen (se "retlen" não for NULL) irá
ser definido como o comprimento, em bytes, desse caractere.

O valor de “flags” determina o comportamento quando “s” não aponta para um bom
caractere UTF-8 formado. Se "sinalizadores" for 0, quando uma malformação for encontrada, zero será
retornado e *retlen é definido para que ("s" + *retlen) seja a próxima posição possível
em "s" que poderia iniciar um caractere não malformado. Além disso, se avisos UTF-8
não foram desativados lexicalmente, um aviso será gerado.

Vários sinalizadores ALLOW podem ser definidos em "sinalizadores" para permitir (e não avisar) indivíduos
tipos de malformações, como a sequência ser muito longa (ou seja, quando há
é uma sequência mais curta que pode expressar o mesmo ponto de código; sequências muito longas são
expressamente proibido no padrão UTF-8 devido a possíveis problemas de segurança).
Outro exemplo de malformação é o primeiro byte de um caractere que não é legal
primeiro byte. Ver utf8.h para obter a lista de tais sinalizadores. Para strings de comprimento 0 permitidas,
esta função retorna 0; para sequências longas permitidas, o ponto de código computado
é retornado; para todas as outras malformações permitidas, o Unicode REPLACEMENT
CHARACTER é retornado, pois não tem valor razoável determinável.

O sinalizador UTF8_CHECK_ONLY substitui o comportamento quando um não permitido (por outro
sinalizadores) malformação é encontrada. Se este sinalizador estiver definido, a rotina assume que o
chamador irá gerar um aviso, e esta função irá silenciosamente definir "retlen" para
"-1" (convertido em "STRLEN") e retorna zero.

Observe que esta API requer desambiguação entre a decodificação bem-sucedida de um "NUL"
caractere e um retorno de erro (a menos que o sinalizador UTF8_CHECK_ONLY esteja definido), como em
em ambos os casos, 0 é retornado. Para desambiguar, com retorno zero, veja se o primeiro
byte de "s" também é 0. Nesse caso, a entrada foi "NUL"; caso contrário, a entrada tinha um
erro.

Certos pontos de código são considerados problemáticos. Estes são substitutos do Unicode,
Não caracteres Unicode e pontos de código acima do máximo Unicode de 0x10FFFF. Por
padrão, estes são considerados pontos de código regulares, mas certas situações justificam
tratamento especial para eles. Se "flags" contiver UTF8_DISALLOW_ILLEGAL_INTERCHANGE,
todas as três classes são tratadas como malformações e tratadas como tal. As bandeiras
UTF8_DISALLOW_SURROGATE, UTF8_DISALLOW_NONCHAR e UTF8_DISALLOW_SUPER (significando
acima do máximo legal do Unicode) pode ser definido para proibir essas categorias
individualmente.

Os sinalizadores UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, UTF8_WARN_NONCHAR,
e UTF8_WARN_SUPER farão com que mensagens de aviso sejam geradas para seus respectivos
categorias, mas caso contrário os pontos de código são considerados válidos (não
malformações). Para que uma categoria seja tratada como uma malformação e aumente
um aviso, especifique os sinalizadores WARN e DISALLOW. (Mas observe que os avisos são
não gerado se desativado lexicamente nem se UTF8_CHECK_ONLY também for especificado.)

Pontos de código muito grandes (acima de 0x7FFF_FFFF) são considerados mais problemáticos do que
os demais que estão acima do máximo legal do Unicode. Existem vários motivos:
eles requerem pelo menos 32 bits para representá-los em plataformas ASCII, não são
representável em plataformas EBCDIC, e a especificação UTF-8 original
nunca ultrapassou esse número (o limite atual de 0x10FFFF foi imposto posteriormente). (O
os menores, aqueles que cabem em 32 bits, são representáveis ​​por um UV em ASCII
plataformas, mas não por um IV, o que significa que o número de operações que podem ser
executada neles é bastante restrita.) A codificação UTF-8 em plataformas ASCII para
esses grandes pontos de código começam com um byte contendo 0xFE ou 0xFF. O
O sinalizador UTF8_DISALLOW_FE_FF fará com que eles sejam tratados como malformações, enquanto
permitindo pontos de código menores acima do Unicode. (É claro que UTF8_DISALLOW_SUPER irá
trate todos os pontos de código Unicode acima, incluindo estes, como malformações.)
Da mesma forma, UTF8_WARN_FE_FF atua exatamente como os outros sinalizadores WARN, mas aplica-se apenas
para esses pontos de código.

Todos os outros pontos de código correspondentes a caracteres Unicode, incluindo uso privado
e os que ainda não foram designados, nunca são considerados malformados e nunca avisados.

UV utf8n_to_uvchr(const U8 *s, STRLEN curlen,
STRLEN *retlen, bandeiras U32)

utf8n_to_uvuni
Em vez disso, use "utf8_to_uvchr_buf" ou raramente "utf8n_to_uvchr".

Esta função foi útil para código que queria lidar com EBCDIC e ASCII
plataformas com propriedades Unicode, mas a partir do Perl v5.20, as distinções
entre as plataformas ficaram praticamente invisíveis para a maioria dos códigos, então isso
é muito improvável que a função seja o que você deseja. Se você precisar disso
funcionalidade, use em vez disso "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" ou
"NATIVE_TO_UNI(utf8n_to_uvchr(...))".

UV utf8n_to_uvuni(const U8 *s, STRLEN curlen,
STRLEN *retlen, bandeiras U32)

UTF8SKIP
retorna o número de bytes no caractere codificado em UTF-8 cujo primeiro (talvez
apenas) byte é apontado por "s".

STRLEN UTF8SKIP(caracteres*s)

utf8_distance
Retorna o número de caracteres UTF-8 entre os ponteiros UTF-8 "a" e "b".

AVISO: use somente se você *sabe* que os ponteiros apontam dentro do mesmo UTF-8
tampão.

IV utf8_distance(const U8 *a, const U8 *b)

utf8_hop
Retorna os ponteiros UTF-8 "s" deslocados por caracteres "off", seja direto ou
para trás.

AVISO: não use o seguinte, a menos que você *sabe* que "off" está dentro dos dados UTF-8
apontado por "s" *e* que na entrada "s" está alinhado no primeiro byte de
caractere ou logo após o último byte de um caractere.

U8* utf8_hop(const U8 *s, I32 desativado)

utf8_length
Retorna o comprimento da string "s" codificada em caracteres UTF-8 em caracteres. Para em
"e" (inclusive). Se "e <s" ou se a varredura passar de "e", grasna.

STRLEN utf8_length(const U8* s, const U8 *e)

utf8_to_bytes
NOTA: esta função é experimental e pode ser alterada ou removida sem aviso prévio.

Converte uma string "s" de comprimento "len" de UTF-8 em codificação de byte nativa.
Ao contrário de "bytes_to_utf8", isso substitui a string original e atualiza "len" para
contém o novo comprimento. Retorna zero em caso de falha, definindo "len" como -1.

Se você precisar de uma cópia da string, consulte "bytes_from_utf8".

U8* utf8_to_bytes(U8 *s, STRLEN *len)

utf8_to_uvchr_buf
Retorna o ponto de código nativo do primeiro caractere na string "s" que é
assumido como estando na codificação UTF-8; "enviar" aponta para 1 além do final de "s".
*retlen será definido com o comprimento, em bytes, desse caractere.

Se "s" não apontar para um caractere UTF-8 bem formado e os avisos UTF8 forem
habilitado, zero é retornado e *retlen é definido (se "retlen" não for NULL) como -1. Se
esses avisos estão desativados, o valor calculado, se bem definido (ou o Unicode
REPLACEMENT CHARACTER se não), é retornado silenciosamente e *retlen é definido (se
"retlen" não é NULL) para que ("s" + *retlen) seja a próxima posição possível em "s"
que poderia iniciar um caractere não malformado. Veja "utf8n_to_uvchr" para detalhes sobre
quando o CARACTER DE SUBSTITUIÇÃO é retornado.

UV utf8_to_uvchr_buf(const U8 *s, const U8 *enviar,
STRLEN *retlen)

utf8_to_uvuni_buf
DESCONTINUADA! É planejado remover esta função de uma versão futura do Perl.
Não o use para novo código; remova-o do código existente.

Somente em circunstâncias muito raras o código precisa lidar em Unicode (como
em oposição aos pontos de código nativos). Nesses poucos casos, use
"NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" em vez disso.

Retorna o ponto de código Unicode (não nativo) do primeiro caractere da string
"s" que se presume estar na codificação UTF-8; "enviar" aponta para 1 além do final de
"é". "retlen" será definido com o comprimento, em bytes, desse caractere.

Se "s" não apontar para um caractere UTF-8 bem formado e os avisos UTF8 forem
habilitado, zero é retornado e *retlen é definido (se "retlen" não for NULL) como -1. Se
esses avisos estão desativados, o valor calculado se estiver bem definido (ou o Unicode
CARACTER DE SUBSTITUIÇÃO, se não) é retornado silenciosamente e *retlen é definido (se
"retlen" não é NULL) para que ("s" + *retlen) seja a próxima posição possível em "s"
que poderia iniciar um caractere não malformado. Veja "utf8n_to_uvchr" para detalhes sobre
quando o CARACTER DE SUBSTITUIÇÃO é retornado.

UV utf8_to_uvuni_buf(const U8 *s, const U8 *enviar,
STRLEN *retlen)

UVCHR_SKIP
retorna o número de bytes necessários para representar o ponto de código "cp" quando codificado
como UTF-8. "cp" é um ponto de código nativo (ASCII ou EBCDIC) se for menor que 255; a
Ponto de código Unicode caso contrário.

STRLEN UVCHR_SKIP(UV cp)

uvchr_to_utf8
Adiciona a representação UTF-8 do ponto de código nativo "uv" ao final do
string "d"; "d" deve ter pelo menos "UVCHR_SKIP(uv)+1" (até "UTF8_MAXBYTES+1")
bytes livres disponíveis. O valor de retorno é o ponteiro para o byte após o final
do novo personagem. Em outras palavras,

d = uvchr_to_utf8(d, uv);

é a maneira recomendada de dizer com reconhecimento de caracteres nativos

*(d++) = uv;

Esta função aceita qualquer UV como entrada. Para proibir ou alertar sobre código não Unicode
pontos, ou aqueles que podem ser problemáticos, consulte "uvchr_to_utf8_flags".

U8* uvchr_to_utf8(U8 *d, UV uv)

uvchr_to_utf8_flags
Adiciona a representação UTF-8 do ponto de código nativo "uv" ao final do
string "d"; "d" deve ter pelo menos "UVCHR_SKIP(uv)+1" (até "UTF8_MAXBYTES+1")
bytes livres disponíveis. O valor de retorno é o ponteiro para o byte após o final
do novo personagem. Em outras palavras,

d = uvchr_to_utf8_flags(d, uv, sinalizadores);

ou, na maioria dos casos,

d = uvchr_to_utf8_flags(d, uv, 0);

Esta é a maneira compatível com Unicode de dizer

*(d++) = uv;

Esta função irá converter para UTF-8 (e não avisar) até mesmo pontos de código que não são
Unicode legal ou problemático, a menos que "sinalizadores" contenham um ou mais dos
seguintes sinalizadores:

Se "uv" for um ponto de código substituto Unicode e UNICODE_WARN_SURROGATE estiver definido, o
A função gerará um aviso, desde que os avisos UTF8 estejam habilitados. Se em vez disso
UNICODE_DISALLOW_SURROGATE for definido, a função falhará e retornará NULL. Se
ambos os sinalizadores estão definidos, a função avisará e retornará NULL.

Os sinalizadores UNICODE_WARN_NONCHAR e UNICODE_DISALLOW_NONCHAR afetam como o
função lida com um não-caractere Unicode. E da mesma forma, o UNICODE_WARN_SUPER
e os sinalizadores UNICODE_DISALLOW_SUPER afetam o tratamento de pontos de código que estão acima
o máximo Unicode de 0x10FFFF. Pontos de código acima de 0x7FFF_FFFF (que são pares
menos portátil) pode ser avisado e/ou não permitido mesmo se outro código Unicode acima
pontos são aceitos pelos flags UNICODE_WARN_FE_FF e UNICODE_DISALLOW_FE_FF.

E finalmente, o sinalizador UNICODE_WARN_ILLEGAL_INTERCHANGE seleciona todos os quatro
acima dos sinalizadores WARN; e UNICODE_DISALLOW_ILLEGAL_INTERCHANGE seleciona todos os quatro
Sinalizadores PROIBIDOS.

U8* uvchr_to_utf8_flags(U8 *d, UV uv, sinalizadores UV)

uvoffuni_to_utf8_flags
ESTA FUNÇÃO DEVE SER UTILIZADA APENAS EM CIRCUNSTÂNCIAS MUITO ESPECIALIZADAS. Em vez de,
Quase todos os código rede de apoio social usar "uvchr_to_utf8" or "uvchr_to_utf8_flags".

Esta função é semelhante a elas, mas a entrada é um Unicode estrito (em oposição a
nativo) ponto de código. Somente em circunstâncias muito raras o código não deve usar o
ponto de código nativo.

Para obter detalhes, consulte a descrição de "uvchr_to_utf8_flags".

U8* uvoffuni_to_utf8_flags(U8 *d, UV uv, sinalizadores UV)

uvuni_to_utf8_flags
Em vez disso, você quase certamente deseja usar "uvchr_to_utf8" ou "uvchr_to_utf8_flags".

Esta função é um sinônimo obsoleto de "uvoffuni_to_utf8_flags", que por si só,
embora não esteja obsoleto, deve ser usado apenas em circunstâncias isoladas. Esses
funções eram úteis para código que queria lidar com EBCDIC e ASCII
plataformas com propriedades Unicode, mas a partir do Perl v5.20, as distinções
entre as plataformas ficaram praticamente invisíveis para a maioria dos códigos, então isso
é muito improvável que a função seja o que você deseja.

U8* uvuni_to_utf8_flags(U8 *d, UV uv, sinalizadores UV)

Variáveis criado by "xsubpp" e "xsubpp" interno funções

novoXSproto
Usado por "xsubpp" para conectar XSUBs como subs Perl. Adiciona protótipos Perl aos subs.

XS_APIVERSION_BOOTCHECK
Macro para verificar se a versão da API Perl em que um módulo XS foi compilado
corresponde à versão da API do interpretador Perl no qual está sendo carregado.

XS_APIVERSION_BOOTCHECK;

XS_VERSION
O identificador de versão de um módulo XS. Isso geralmente é tratado automaticamente por
"ExtUtils::MakeMaker". Consulte "XS_VERSION_BOOTCHECK".

XS_VERSION_BOOTCHECK
Macro para verificar se a variável $VERSION de um módulo PM corresponde à do módulo XS
Variável "XS_VERSION". Isso geralmente é tratado automaticamente por "xsubpp". Ver
"O VERSIONCHECK: Palavra-chave" em perlxs.

XS_VERSION_BOOTCHECK;

Versão

nova versão
Retorna um novo objeto de versão baseado no SV passado:

SV *sv = nova_versão(SV *ver);

Não altera o passado na versão SV. Consulte "upg_version" se desejar atualizar o
SV.

SV* nova_versão(SV *ver)

pré-digitalização_versão
Valide que uma determinada string pode ser analisada como um objeto de versão, mas não
realmente execute a análise. Pode usar regras de validação estritas ou frouxas. Pode
opcionalmente, defina uma série de variáveis ​​de dica para salvar o código de análise em algum momento quando
tokenização.

const char* prescan_version(const char *s, bool strict,
const char** errstr,
bool *v²,
int *ssaw_decimal,
int *largura, bool *salfa)

scan_versão
Retorna um ponteiro para o próximo caractere após a string da versão analisada, também
como atualizar o SV aprovado para um RV.

A função deve ser chamada com um SV já existente, como

SV = novoSV(0);
s = scan_version(s, SV *sv, bool qv);

Executa algum pré-processamento na string para garantir que ela tenha o formato correto
características de uma versão. Sinaliza o objeto se ele contém um sublinhado
(o que indica que esta é uma versão alfa). O booleano qv denota que a versão
deve ser interpretado como se tivesse vários decimais, mesmo que não tenha.

const char* scan_version(const char *s, SV *rv, bool qv)

versão_upg
Atualização local do SV fornecido para um objeto de versão.

SV *sv = versão_upg(SV *sv, bool qv);

Retorna um ponteiro para o SV atualizado. Defina o booleano qv se quiser forçar
esta SV deve ser interpretada como uma versão "estendida".

SV* versão_upg(SV *ver, bool qv)

vcmp Versão com reconhecimento de objeto cmp. Ambos os operandos já devem ter sido convertidos em
objetos de versão.

int vcmp(SV *lhv, SV *rhv)

vnormal Aceita um objeto de versão e retorna a representação de string normalizada. Chamar
gostar:

sv = vnormal(rv);

NOTA: você pode passar diretamente pelo objeto ou pelo SV contido no RV.

O SV retornado tem uma recontagem de 1.

SV* vnormal(SV *vs)

vnumify Aceita um objeto de versão e retorna a representação de ponto flutuante normalizada.
Ligue como:

sv = vnumify(rv);

NOTA: você pode passar diretamente pelo objeto ou pelo SV contido no RV.

O SV retornado tem uma recontagem de 1.

SV* vnumificar(SV *vs)

vstringify
Para manter a compatibilidade máxima com versões anteriores do Perl, este
função retornará a notação de ponto flutuante ou vários pontos
notação, dependendo se a versão original continha 1 ou mais pontos,
respectivamente.

O SV retornado tem uma recontagem de 1.

SV* vstringify(SV *vs)

vverify Valida se o SV contém uma estrutura interna válida para um objeto de versão. Isto
pode ser passado o objeto de versão (RV) ou o próprio hash (HV). Se o
estrutura é válida, ela retorna o HV. Se a estrutura for inválida, ela retorna
NULO.

SV *hv = vverificar(sv);

Observe que isso apenas confirma a estrutura mínima (para não ficar confuso
por classes derivadas que podem conter entradas de hash adicionais):

SV* vverificar(SV *vs)

Aviso e Dieing

coak Esta é uma interface XS para a função "die" do Perl.

Pegue um padrão de formato no estilo sprintf e uma lista de argumentos. Estes são usados ​​para gerar
uma mensagem de cadeia. Se a mensagem não terminar com uma nova linha, ela será
estendido com alguma indicação da localização atual no código, conforme descrito
para "mess_sv".

A mensagem de erro será usada como exceção, por padrão retornando o controle para
o "eval" mais próximo, mas sujeito a modificação por um $SIG{__DIE__}
manipulador. De qualquer forma, a função “coak” nunca retorna normalmente.

Por razões históricas, se "pat" for nulo então o conteúdo de "ERRSV" ($@) será
usado como uma mensagem de erro ou objeto em vez de construir uma mensagem de erro a partir
argumentos. Se você quiser lançar um objeto que não seja string ou criar uma mensagem de erro em
você mesmo um SV, é preferível usar a função "croak_sv", que não
envolvem derrotar "ERRSV".

coaxar vazio(const char *pat, ...)

croak_no_modify
Exatamente equivalente a "Perl_croak(aTHX_ "%s", PL_no_modify)", mas gera mais conciso
código objeto do que usar "Perl_croak". Menos código usado em caminhos de código de exceção
reduz a pressão do cache da CPU.

void croak_no_modify()

coaxar_sv
Esta é uma interface XS para a função "die" do Perl.

"baseex" é a mensagem ou objeto de erro. Se for uma referência, será usada
como é. Caso contrário, será usado como uma string e, se não terminar com uma nova linha
então será estendido com alguma indicação da localização atual no código,
conforme descrito para "mess_sv".

A mensagem ou objeto de erro será usado como exceção, retornando por padrão
controle para o "eval" anexo mais próximo, mas sujeito a modificação por um
Manipulador $SIG{__DIE__}. De qualquer forma, a função "croak_sv" nunca retorna
normalmente.

Para morrer com uma simples mensagem de string, a função "coak" pode ser mais conveniente.

void croak_sv(SV *baseex)

die Comporta-se da mesma forma que "coak", exceto pelo tipo de retorno. Deve ser usado apenas
onde o tipo de retorno "OP *" é necessário. A função nunca retorna realmente.

OP * morrer(const char *pat, ...)

die_sv Comporta-se da mesma forma que "croak_sv", exceto pelo tipo de retorno. Deve ser usado
somente onde o tipo de retorno "OP *" for necessário. A função nunca realmente
retorna.

OP * die_sv(SV *baseex)

vcroak Esta é uma interface XS para a função "die" do Perl.

"pat" e "args" são um padrão de formato estilo sprintf e argumentos encapsulados
Lista. Estes são usados ​​para gerar uma mensagem de string. Se a mensagem não terminar
com uma nova linha, então ele será estendido com alguma indicação do atual
localização no código, conforme descrito para "mess_sv".

A mensagem de erro será usada como exceção, por padrão retornando o controle para
o "eval" mais próximo, mas sujeito a modificação por um $SIG{__DIE__}
manipulador. De qualquer forma, a função “coak” nunca retorna normalmente.

Por razões históricas, se "pat" for nulo então o conteúdo de "ERRSV" ($@) será
usado como uma mensagem de erro ou objeto em vez de construir uma mensagem de erro a partir
argumentos. Se você quiser lançar um objeto que não seja string ou criar uma mensagem de erro em
você mesmo um SV, é preferível usar a função "croak_sv", que não
envolvem derrotar "ERRSV".

void vcroak(const char *pat, va_list *args)

vwarn Esta é uma interface XS para a função "warn" do Perl.

"pat" e "args" são um padrão de formato estilo sprintf e argumentos encapsulados
Lista. Estes são usados ​​para gerar uma mensagem de string. Se a mensagem não terminar
com uma nova linha, então ele será estendido com alguma indicação do atual
localização no código, conforme descrito para "mess_sv".

A mensagem ou objeto de erro será, por padrão, gravado no erro padrão, mas isso
está sujeito a modificação por um manipulador $SIG{__WARN__}.

Ao contrário de "vcroak", "pat" não pode ser nulo.

void vwarn(const char *pat, va_list *args)

warning Esta é uma interface XS para a função "warn" do Perl.

Pegue um padrão de formato no estilo sprintf e uma lista de argumentos. Estes são usados ​​para gerar
uma mensagem de cadeia. Se a mensagem não terminar com uma nova linha, ela será
estendido com alguma indicação da localização atual no código, conforme descrito
para "mess_sv".

A mensagem ou objeto de erro será, por padrão, gravado no erro padrão, mas isso
está sujeito a modificação por um manipulador $SIG{__WARN__}.

Ao contrário de "coak", "pat" não pode ser nulo.

void warning(const char *pat, ...)

warning_sv Esta é uma interface XS para a função "warn" do Perl.

"baseex" é a mensagem ou objeto de erro. Se for uma referência, será usada
como é. Caso contrário, será usado como uma string e, se não terminar com uma nova linha
então será estendido com alguma indicação da localização atual no código,
conforme descrito para "mess_sv".

A mensagem ou objeto de erro será, por padrão, gravado no erro padrão, mas isso
está sujeito a modificação por um manipulador $SIG{__WARN__}.

Para avisar com uma mensagem simples, a função "avisar" pode ser mais conveniente.

void warning_sv(SV *baseex)

Ilegal funções

As funções a seguir foram sinalizadas como parte da API pública, mas atualmente estão
indocumentado. Use-os por sua conta e risco, pois as interfaces estão sujeitas a alterações.
As funções que não estão listadas neste documento não se destinam ao uso público e devem
NÃO deve ser usado em nenhuma circunstância.

Se você usar uma das funções não documentadas abaixo, você pode considerar criar e
enviando documentação para isso. Se o seu patch for aceito, isso indicará que o
interface é estável (a menos que seja explicitamente marcado de outra forma).

ObterVars
Gv_AMupdate
PerlIO_clearerr
PerlIO_close
PerlIO_context_layers
PerlIO_eof
PerlIO_error
PerlIO_fileno
PerlIO_fill
PerlIO_flush
PerlIO_get_base
PerlIO_get_bufsiz
PerlIO_get_cnt
PerlIO_get_ptr
PerlIO_read
PerlIO_seek
PerlIO_set_cnt
PerlIO_set_ptrcnt
PerlIO_setlinebuf
PerlIO_stderr
PerlIO_stdin
PerlIO_stdout
PerlIO_tell
PerlIO_unread
PerlIO_write
amagic_call
amagic_deref_call
qualquer_dup
atfork_lock
atfork_unlock
av_arylen_p
av_iter_p
block_gimme
call_atexit
lista_de_chamadas
calloc
cast_i32
elenco_iv
cast_ulong
cast_uv
ck_warner
ck_warner_d
avisar
ckwarn_d
clone_params_del
clone_params_new
croak_memory_wrap
croak_nocontext
csighandler
cx_dump
cx_dup
cxinc
deb
deb_nocontext
debop
debprofdump
debstack
debstackptrs
delicado
despacho_sinais
morrer_nocontext
dirp_dup
do_aspawn
do_binmode
do_fechar
do_gv_dump
do_gvgv_dump
do_hv_dump
do_join
do_magic_dump
do_op_dump
do_open
do_open9
do_openn
do_pmop_dump
do_spawn
do_spawn_nowait
do_sprintf
do_sv_dump
fazendo_taint
doref
relaxar
dowantarray
dump_eval
dump_form
dump_indent
dump_mstats
dump_sub
dump_vindent
filtro_adicionar
filtro_del
filtro_leitura
foldEQ_latin1
formulário_nocontext
fp_dup
fprintf_nocontext
free_global_struct
free_tmps
get_context
get_mstats
get_op_descs
get_op_names
get_ppaddr
get_vtbl
gp_dup
gp_free
gp_ref
gv_AVadd
gv_HVadd
gv_IOadd
gv_SVadd
gv_add_by_type
gv_autoload4
gv_autoload_pv
gv_autoload_pvn
gv_autoload_sv
gv_check
gv_dump
gv_efullname
gv_efullname3
gv_efullname4
gv_fetchfile
gv_fetchfile_flags
gv_fetchpv
gv_fetchpvn_flags
gv_fetchsv
gv_nome completo
gv_nomecompleto3
gv_nomecompleto4
gv_handler
gv_name_set
ele_dup
hek_dup
hv_common
hv_common_key_len
hv_delayfree_ent
hv_eiter_p
hv_eiter_set
hv_free_ent
hv_ksplit
hv_name_set
hv_placeholders_get
hv_placeholders_set
hv_rand_set
hv_riter_p
hv_riter_set
ibcmp_utf8
init_global_struct
init_stacks
init_tm
instr
is_lvalue_sub
deixar_escopo
load_module_nocontext
despejo_mágico
Malloc
markstack_grow
bagunça_nocontext
livre
mg_dup
tamanho_mg
mini_mktime
mais interruptores
mro_get_from_name
mro_get_private_data
mro_set_mro
mro_set_private_data
meu_atof
meu_atof2
minha_bcopy
meu_bzero
meu_chsize
meu_cxt_index
meu_cxt_init
meu_dirfd
minha_saída
minha_falha_saída
meu_fflush_all
meu_garfo
meu_lstat
meu_memcmp
meu_memset
meu_pclose
meu_popen
minha_popen_list
meu_setenv
meu_socketpair
meu_stat
meu_strftime
novoANONATTRSUB
novoANONHASH
novoANONLIST
novoANONSUB
novoATTRSUB
novoAVREF
novoCVREF
nova forma
novoGVREF
novoGVgen
novoGVgen_flags
novoHVREF
novoHVhv
novoIO
novoMYSUB
novoPROG
novoRV
novoSUB
novoSVREF
novoSVpvf_nocontext
new_stackinfo
ninstr
op_refcnt_lock
op_refcnt_unlock
analisador_dup
perl_alloc_using
perl_clone_using
pmop_dump
escopo_pop
pré-comp
pregexec
livre de gravidez
pregfree2
printf_nocontext
ptr_table_fetch
ptr_table_free
ptr_table_new
ptr_table_split
ptr_table_store
push_scope
recompilar
re_dup_guts
re_intuit_start
re_intuit_string
realocar
reentrante_livre
reentrante_init
reentrante_retry
tamanho_reentrante
ref
reg_named_buff_all
reg_named_buff_exists
reg_named_buff_fetch
reg_named_buff_firstkey
reg_named_buff_nextkey
reg_named_buff_scalar
regclass_swash
despejo de registro
regdupe_internal
regexec_flags
regfree_internal
reginitcolors
renext
repetircpy
rninstr
sinal
rsignal_state
runops_debug
runops_standard
rvpv_dup
safesyscalloc
safesysfree
safesysmalloc
safesysrealloc
salvar_I16
salvar_I32
salvar_I8
save_adelete
save_aelem
save_aelem_flags
salvar_aloc
save_aptr
save_ary
salvar_bool
salvar_clearsv
salvar_excluir
save_destructor
save_destructor_x
save_freeop
save_freepv
save_freesv
save_generic_pvref
save_generic_svref
salvar_gp
salvar_hash
save_hdelete
salvar_helem
save_helem_flags
salvar_dicas
save_hptr
salvar_int
salvar_item
salvar_iv
lista_salva
salvar_longo
save_mortalizesv
salvar_nogv
salvar_op
save_padsv_and_mortalize
salvar_pptr
save_pushi32ptr
save_pushptr
save_pushptrptr
save_re_context
salvar_escalar
save_set_svflags
save_shared_pvref
salvar_sptr
salvar_svref
save_vptr
savestack_grow
savestack_grow_cnt
número_de_scan
scan_vstring
semente
conjunto_contexto
set_numeric_local
set_numeric_radix
set_numeric_standard
compartilhar_hek
si_dup
ss_dup
stack_grow
start_subparse
str_to_version
sv_2iv
sv_2pv
sv_2uv
sv_catpvf_mg_nocontext
sv_catpvf_nocontext
sv_dup
sv_dup_inc
sv_peek
sv_pvn_nomg
sv_setpvf_mg_nocontext
sv_setpvf_nocontext
swash_fetch
swash_init
inicialização_sys
sys_init3
sys_intern_clear
sys_intern_dup
sys_intern_init
termo_sistema
taint_env
taint_proper
Desconectar
cancelar compartilhamento
utf16_to_utf8
utf16_to_utf8_reversed
uvuni_to_utf8
vdeb
vformulário
vload_module
vnewSVpvf
vwarner
warning_nocontext
warner
warning_nocontext
qual é a assinatura
quesig_pv
whosig_pvn
whosig_sv

AUTORES

Até maio de 1997, este documento foi mantido por Jeff Okamoto[email protegido]>. Isto é
agora mantido como parte do próprio Perl.

Com muita ajuda e sugestões de Dean Roehrich, Malcolm Beattie, Andreas Koenig,
Paul Hudson, Ilya Zakharevich, Paul Marquess, Neil Bowers, Matthew Green, Tim Bunce,
Spider Boardman, Ulrich Pfeifer, Stephen McCamant e Gurusamy Sarathy.

Listagem de API originalmente por Dean Roehrich[email protegido]>.

Atualizado para ser gerado automaticamente a partir de comentários na fonte por Benjamin Stuhl.

Use perlapi online usando serviços onworks.net