perlapi - Online nel Cloud

PROGRAMMA:

NOME

perlapi - documentazione generata automaticamente per l'API pubblica di perl

DESCRIZIONE

Questo file contiene la documentazione dell'API pubblica perl generata da incorporare.pl,
in particolare un elenco di funzioni, macro, flag e variabili che possono essere utilizzate da
scrittori di estensioni Alla fine c'è un elenco di funzioni che devono ancora essere documentate.
Le interfacce di questi sono soggette a modifiche senza preavviso. Tutto ciò che non è elencato qui è
non fa parte dell'API pubblica e non dovrebbe essere utilizzata dagli autori di estensioni. Per questi
ragioni, l'uso alla cieca delle funzioni elencate in proto.h deve essere evitato durante la scrittura
estensioni.

Nota che tutte le variabili globali dell'API Perl devono essere referenziate con il prefisso "PL_". Ancora,
quelli non elencati qui non devono essere utilizzati dagli autori di estensioni e possono essere modificati o
rimosso senza preavviso; lo stesso con le macro. Alcune macro sono fornite per compatibilità con
i nomi più vecchi e disadorni, ma questo supporto potrebbe essere disabilitato in una versione futura.

Perl è stato originariamente scritto per gestire solo US-ASCII (cioè i caratteri il cui ordinale
i numeri sono nell'intervallo 0 - 127). E documentazione e commenti possono ancora usare il termine
ASCII, quando a volte in realtà si intende l'intero intervallo da 0 a 255.

Nota che Perl può essere compilato ed eseguito in ASCII o EBCDIC (vedi perlebcdic).
La maggior parte della documentazione (e anche i commenti nel codice) ignorano la possibilità EBCDIC.
Per quasi tutti gli scopi le differenze sono trasparenti. Ad esempio, sotto EBCDIC,
invece di UTF-8, viene utilizzato UTF-EBCDIC per codificare le stringhe Unicode, quindi ogni volta che questo
la documentazione fa riferimento a "utf8" (e varianti di quel nome, inclusi i nomi delle funzioni),
significa anche (essenzialmente in modo trasparente) "UTF-EBCDIC". Ma gli ordinali dei personaggi
differiscono tra ASCII, EBCDIC e le codifiche UTF e una stringa codificata in UTF-EBCDIC
può occupare più byte rispetto a UTF-8.

L'elenco seguente è alfabetico, senza distinzione tra maiuscole e minuscole.

"Dammi" Valori

GIMME Una versione retrocompatibile di "GIMME_V" che può restituire solo "G_SCALAR" o
"G_ARRAY"; in un contesto vuoto, restituisce "G_SCALAR". Deprecato. Usa "GIMME_V"
anziché.

U32 DAMMI

GIMME_V L'equivalente di XSUB-writer di "wantarray" di Perl. Restituisce "G_VOID", "G_SCALAR"
o "G_ARRAY" rispettivamente per il contesto vuoto, scalare o elenco. Vedi perlcall per a
esempio di utilizzo.

U32 GIMME_V

G_ARRAY Utilizzato per indicare il contesto dell'elenco. Vedi "GIMME_V", "GIMME" e perlcall.

G_SCARTA
Indica che gli argomenti restituiti da un callback devono essere eliminati. Vedere
perlcall.

G_EVAL Usato per forzare un wrapper Perl "eval" attorno a un callback. Vedi perlcall.

G_NOARGS
Indica che nessun argomento viene inviato a un callback. Vedi perlcall.

G_SCALARE
Usato per indicare il contesto scalare. Vedere "GIMME_V", "GIMME" e perlcall.

G_VOID Usato per indicare il contesto vuoto. Vedi "GIMME_V" e perlcall.

Italia Manipolazione funzioni

AvFILL Uguale a "av_top_index()". Deprecato, usa invece "av_top_index()".

int AvFILL(AV*av)

av_clear
Libera tutti gli elementi di un array, lasciandolo vuoto. L'equivalente XS di
"@array = ()". Vedi anche "av_undef".

Nota che è possibile che le azioni di un distruttore chiamato direttamente o
indirettamente liberando un elemento dell'array potrebbe causare il conteggio dei riferimenti di
l'array stesso da ridurre (ad es. cancellando una voce nella tabella dei simboli). Così
è una possibilità che l'AV possa essere stato liberato (o addirittura riassegnato) su
tornare dalla chiamata a meno che non si tratti di un riferimento ad essa.

void av_clear(AV *av)

av_create_and_push
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Spingere un SV alla fine dell'array, creando l'array se necessario. Un piccolo
funzione di supporto interna per rimuovere un idioma comunemente duplicato.

void av_create_and_push(AV **const avp,
SV *valore costante)

av_create_and_unshift_one
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Annulla lo spostamento di un SV all'inizio dell'array, creando l'array se necessario.
Una piccola funzione di supporto interno per rimuovere un idioma comunemente duplicato.

SV** av_create_and_unshift_one(AV **const avp,
SV *valore costante)

av_delete
Elimina l'elemento indicizzato da "chiave" dall'array, rende l'elemento mortale e
lo restituisce. Se "flags" è uguale a "G_DISCARD", l'elemento viene liberato e null è
restituito. Equivalente Perl: "my $elem = delete($myarray[$idx]);" per il
versione non "G_DISCARD" e un contesto vuoto "delete($myarray[$idx]);" per il
Versione "G_DISCARD".

SV* av_delete(AV *av, chiave SSize_t, flag I32)

av_esiste
Restituisce vero se l'elemento indicizzato da "chiave" è stato inizializzato.

Ciò si basa sul fatto che gli elementi dell'array non inizializzati sono impostati su NULL.

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

bool av_exists(AV *av, chiave SSize_t)

av_estendere
Estendere in anticipo un array. La "chiave" è l'indice a cui dovrebbe essere l'array
esteso.

void av_extend(AV *av, chiave SSize_t)

av_fetch
Restituisce l'SV all'indice specificato nell'array. La "chiave" è l'indice. Se
lval è vero, hai la garanzia di riavere un vero SV (nel caso non fosse reale
prima), che è poi possibile modificare. Verifica che il valore restituito non sia nullo
prima di dereferenziarlo a "SV*".

Per ulteriori informazioni, vedere "Capire la magia degli hash e degli array legati" in perlguts
informazioni su come utilizzare questa funzione su array collegati.

L'equivalente approssimativo perl è $myarray[$idx].

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

av_fill Imposta l'indice più alto nell'array al numero dato, equivalente a Perl's
"$#array = $fill;".

Il numero di elementi nell'array sarà "fill + 1" dopo av_fill() ritorna.
Se l'array era precedentemente più corto, vengono impostati gli elementi aggiuntivi aggiunti
a NULLO. Se l'array era più lungo, gli elementi in eccesso vengono liberati.
"av_fill(av, -1)" è lo stesso di "av_clear(av)".

void av_fill(AV *av, SSize_t riempimento)

av_len Uguale a "av_top_index". Nota che, a differenza di quanto suggerisce il nome, restituisce il
indice più alto nell'array, quindi per ottenere la dimensione dell'array è necessario utilizzare
"av_len(av) + 1". Questo è diverso da "sv_len", che restituisce ciò che ti aspetteresti.

Ssize_t av_len(AV *av)

av_make Crea un nuovo AV e lo popola con un elenco di SV. Gli SV vengono copiati in
array, in modo che possano essere liberati dopo la chiamata a av_make. Il nuovo AV avrà un
conteggio di riferimento di 1.

Equivalente Perl: "my @new_array = ($scalare1, $scalare2, $scalare3...);"

AV* av_make(STe_t size, SV **strp)

av_pop Rimuove un SV dalla fine dell'array, riducendo la sua dimensione di uno e restituendo
l'SV (trasferimento del controllo di un conteggio di riferimento) al chiamante. ritorna
&PL_sv_undef se l'array è vuoto.

Equivalente Perl: "pop(@myarray);"

SV*av_pop(AV *av)

av_push Inserisce un SV alla fine dell'array. L'array crescerà automaticamente fino a
accogliere l'addizione. Questo prende la proprietà di un conteggio di riferimento.

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

void av_push(AV *av, SV *val)

av_shift
Rimuove un SV dall'inizio dell'array, riducendone le dimensioni di uno e restituendolo
l'SV (trasferimento del controllo di un conteggio di riferimento) al chiamante. ritorna
&PL_sv_undef se l'array è vuoto.

Equivalente Perl: "shift(@myarray);"

SV* av_shift(AV *av)

av_store
Memorizza un SV in un array. L'indice dell'array è specificato come "chiave". Il ritorno
il valore sarà NULL se l'operazione non è riuscita o se il valore non ha bisogno di essere
effettivamente memorizzato all'interno dell'array (come nel caso degli array legati). Altrimenti, è
può essere dereferenziato per ottenere "SV*" che era memorizzato lì (= "val")).

Si noti che il chiamante è responsabile di incrementare adeguatamente il conteggio dei riferimenti
di "val" prima della chiamata e decrementandolo se la funzione ha restituito NULL.

Equivalente approssimativo di Perl: "$myarray[$key] = $val;".

Per ulteriori informazioni, vedere "Capire la magia degli hash e degli array legati" in perlguts
informazioni su come utilizzare questa funzione su array collegati.

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

av_index
Uguale a "av_top_index()".

int av_tindex(AV*av)

av_top_index
Restituisce l'indice più alto nell'array. Il numero di elementi nell'array è
"av_top_index(av) + 1". Restituisce -1 se l'array è vuoto.

L'equivalente Perl per questo è $#myarray.

(Una forma leggermente più breve è "av_tindex".)

Ssize_t av_top_index(AV *av)

av_undef
Non definisce l'array. L'equivalente XS di "undef(@array)".

Oltre a liberare tutti gli elementi dell'array (come "av_clear()"), anche questo
libera la memoria utilizzata da av per memorizzare il suo elenco di scalari.

Vedere "av_clear" per una nota sull'eventuale invalidità dell'array al ritorno.

void av_undef(AV *av)

av_unshift
Annulla lo spostamento del numero dato di valori "undef" all'inizio dell'array. Il
array crescerà automaticamente per accogliere l'aggiunta. Devi quindi usare
"av_store" per assegnare valori a questi nuovi elementi.

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

void av_unshift(AV *av, SSize_t num)

get_av Restituisce l'AV dell'array Perl globale o pacchetto specificato con il nome dato
(quindi non funzionerà su variabili lessicali). "flag" vengono passati a "gv_fetchpv". Se
"GV_ADD" è impostato e la variabile Perl non esiste, verrà creata. Se
"flags" è zero e la variabile non esiste, quindi viene restituito NULL.

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

NOTA: la forma perl_ di questa funzione è deprecata.

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

newAV Crea un nuovo AV. Il conteggio dei riferimenti è impostato su 1.

Equivalente Perl: "my @array;".

AV* nuovoAV()

sortsv Ordina un array. Ecco un esempio:

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

Attualmente questo usa sempre mergesort. Vedi sortsv_flags per una maggiore flessibilità
routine.

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

sortsv_flags
Ordina un array, con varie opzioni.

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

"xsubpp" variabili e a interno funzioni

ax Variabile che viene impostata da "xsubpp" per indicare l'offset della base dello stack, utilizzata dal
Macro "ST", "XSprePUSH" e "XSRETURN". La macro "dMARK" deve essere chiamata prima
per impostare la variabile "MARK".

I32 ascia

CLASS Variabile che viene impostata da "xsubpp" per indicare il nome della classe per un C++ XS
costruttore. Questo è sempre un "char*". Guarda questo".

carattere* CLASS

dAX Imposta la variabile "ax". Questo di solito viene gestito automaticamente da "xsubpp" di
chiamando "dXSARGS".

dAX;

dAXMARK Imposta la variabile "ax" e la variabile del marker stack "mark". Questo è di solito
gestito automaticamente da "xsubpp" chiamando "dXSARGS".

dAXMARK;

dITEMS Imposta la variabile "items". Questo di solito viene gestito automaticamente da "xsubpp"
chiamando "dXSARGS".

dELEMENTI;

SOTTOBARRA
Imposta qualsiasi variabile necessaria per la macro "UNDERBAR". Era usato per definire
"padoff_du", ma attualmente è un noop. Tuttavia, si consiglia vivamente di continuare
utilizzarlo per garantire la compatibilità passata e futura.

DUNDERBAR;

dXSARGS Imposta stack e mark puntatori per un XSUB, chiamando dSP e dMARK. Imposta il
variabili "ax" e "items" chiamando "dAX" e "dITEMS". Questo di solito è gestito
automaticamente da "xsubpp".

dXSARG;

dXSI32 Imposta la variabile "ix" per un XSUB che ha alias. Questo di solito è gestito
automaticamente da "xsubpp".

dXSI32;

item Variabile che viene impostata da "xsubpp" per indicare il numero di elementi nello stack.
Vedere "Elenchi di parametri a lunghezza variabile" in perlxs.

I32 articoli

ix Variabile che viene impostata da "xsubpp" per indicare quale degli alias di un XSUB era
usato per invocarlo. Vedere "L'ALIAS: Parola chiave" in perlxs.

I32 ix

RETVAL Variabile che viene impostata da "xsubpp" per contenere il valore restituito per un XSUB. Questo è
sempre il tipo corretto per XSUB. Vedi "La variabile RETVAL" in perlxs.

(qualunque cosa) RETVAL

ST Utilizzato per accedere agli elementi nello stack dell'XSUB.

SV* ST(int ix)

QUESTA variabile che è impostata da "xsubpp" per designare l'oggetto in un XSUB C++. Questo
è sempre il tipo corretto per l'oggetto C++. Vedere "CLASS" e "Uso di XS con C++"
in perlx.

(qualunque cosa) QUESTO

SOTTO BARRA
L'SV* corrispondente alla variabile $_. Funziona anche se c'è un lessicale $_ in
scopo.

XS Macro per dichiarare un XSUB e il suo elenco di parametri C. Questo è gestito da "xsubpp".
È come utilizzare la macro XS_EXTERNAL più esplicita.

XS_ESTERNO
Macro per dichiarare un XSUB e il suo elenco di parametri C esportando esplicitamente il
simboli.

XS_INTERNO
Macro per dichiarare un XSUB e il suo elenco di parametri C senza esportare i simboli.
Questo è gestito da "xsubpp" e generalmente preferibile all'esportazione di XSUB
simboli inutilmente.

Richiamata funzioni

call_argv
Esegue un callback alla subroutine Perl specificata con nome e ambito pacchetto con
"argv" (un array di stringhe con terminazione NULL) come argomenti. Vedi perlcall.

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

NOTA: la forma perl_ di questa funzione è deprecata.

I32 call_argv(const char* sub_name, I32 flag,
carattere** argv)

metodo_chiamata
Esegue una richiamata al metodo Perl specificato. L'oggetto benedetto deve essere acceso
la pila. Vedi perlcall.

NOTA: la forma perl_ di questa funzione è deprecata.

I32 call_method(const char* methname, I32 flag)

call_pv Esegue una richiamata al sub Perl specificato. Vedi perlcall.

NOTA: la forma perl_ di questa funzione è deprecata.

I32 call_pv(const char* sub_name, flag I32)

call_sv Esegue una richiamata al sub Perl specificato dall'SV.

Se non viene fornito né il flag "G_METHOD" né "G_METHOD_NAMED", l'SV può essere qualsiasi
di un CV, verrà utilizzato un GV, un riferimento a un CV, un riferimento a un GV o "SvPV(sv)"
come nome del sub da chiamare.

Se viene fornito il flag "G_METHOD", l'SV può essere un riferimento a un CV o
"SvPV(sv)" verrà utilizzato come nome del metodo da chiamare.

Se viene fornito il flag "G_METHOD_NAMED", verrà utilizzato "SvPV(sv)" come nome di
il metodo da chiamare

Alcuni altri valori sono trattati appositamente per uso interno e non dovrebbero essere
è dipeso da.

Vedi perlcall.

NOTA: la forma perl_ di questa funzione è deprecata.

I32 call_sv(SV* sv, flag VOL I32)

INVIO Parentesi aperta su una richiamata. Vedi "LASCIA" e perlcall.

ACCEDERE;

eval_pv Dice a Perl di "eval" la stringa data in un contesto scalare e di restituire un risultato SV*.

NOTA: la forma perl_ di questa funzione è deprecata.

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

eval_sv Dice a Perl di "eval" la stringa nell'SV. Supporta gli stessi flag di
"call_sv", con l'ovvia eccezione di G_EVAL. Vedi perlcall.

NOTA: la forma perl_ di questa funzione è deprecata.

I32 eval_sv(SV* sv, flag I32)

FREETMPS
Parentesi chiusa per provvisori su richiamata. Vedere "SAVETMPS" e perlcall.

FREETMPS;

LEAVE Parentesi chiusa su richiamata. Vedi "INVIO" e perlcall.

PARTIRE;

SALVATEMPS
Staffa di apertura per provvisori su richiamata. Vedi "FREETMPS" e perlcall.

SALVATEMPS;

Carattere Custodie cambiando

toFOLD Converte il carattere specificato in foldcase. Se l'input è tutt'altro che an
Carattere maiuscolo ASCII, viene restituito il carattere di input stesso. Variante
"toFOLD_A" è equivalente. (Non esiste un equivalente "to_FOLD_L1" per l'intero
Latin1, poiché qui è necessaria la generalità completa di "toFOLD_uni".)

U8 per PIEGARE (U8 ch)

toFOLD_uni
Converte il punto di codice Unicode "cp" nella sua versione pieghevole e lo memorizza in
UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer puntava a
da "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte dal foldcase
la versione potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione ripiegata (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

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

in FOLD_utf8
Converte il carattere codificato UTF-8 in "p" nella sua versione pieghevole e memorizza
quello in UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer
puntato da "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte poiché
la versione pieghevole potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione ripiegata (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

Si presume che il carattere di input in "p" sia ben formato.

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

toLOWER Converte il carattere specificato in minuscolo. Se l'input è tutt'altro che an
Carattere maiuscolo ASCII, viene restituito il carattere di input stesso. Variante
"toLOWER_A" è equivalente.

Da U8 a INFERIORE(U8 cat)

aLOWER_L1
Converte il carattere Latin1 specificato in minuscolo. I risultati sono indefiniti
se l'input non rientra in un byte.

Da U8 aLOWER_L1(U8 ch)

aLOWER_LC
Converte il carattere specificato in minuscolo utilizzando le regole della locale corrente, se
possibile; altrimenti restituisce il carattere di input stesso.

Da U8 aLOWER_LC(U8 ch)

aLOWER_uni
Converte il punto di codice Unicode "cp" nella sua versione minuscola e lo memorizza in
UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer puntava a
da "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte dal minuscolo
la versione potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione minuscola (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

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

aLOWER_utf8
Converte il carattere codificato UTF-8 in "p" nella sua versione minuscola e memorizza
quello in UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer
puntato da "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte poiché
la versione minuscola potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione minuscola (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

Si presume che il carattere di input in "p" sia ben formato.

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

toTITLE Converte il carattere specificato in maiuscole/minuscole. Se l'input è tutt'altro che an
Carattere minuscolo ASCII, viene restituito il carattere di input stesso. Variante
"toTITLE_A" è equivalente. (Non c'è "toTITLE_L1" per l'intero intervallo Latin1,
poiché qui è necessaria la generalità completa di "toTITLE_uni". La maiuscola non è una
concetto utilizzato nella gestione delle impostazioni locali, quindi non esiste alcuna funzionalità per questo.)

Da U8 a TITOLO (canali U8)

aTITLE_uni
Converte il punto di codice Unicode "cp" nella sua versione titlecase e lo memorizza in
UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer puntava a
per "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte dal titolo
la versione potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione titlecased (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

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

aTITLE_utf8
Converte il carattere codificato UTF-8 in "p" nella sua versione titlecase e memorizza
quello in UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer
puntato da "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte poiché
la versione titlecase potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione titlecased (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

Si presume che il carattere di input in "p" sia ben formato.

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

toUPPER Converte il carattere specificato in maiuscolo. Se l'input è tutt'altro che an
Carattere minuscolo ASCII, viene restituito il carattere di input stesso. Variante
"toUPPER_A" è equivalente.

Da U8 a SUPERIORE(U8 ch)

aUPPER_uni
Converte il punto di codice Unicode "cp" nella sua versione maiuscola e lo memorizza in
UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer puntava a
da "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte dal maiuscolo
la versione potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione maiuscola (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

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

aUPPER_utf8
Converte il carattere codificato UTF-8 in "p" nella sua versione maiuscola e memorizza
quello in UTF-8 in "s" e la sua lunghezza in byte in "lenp". Nota che il buffer
puntato da "s" deve essere almeno "UTF8_MAXBYTES_CASE+1" byte poiché
la versione maiuscola potrebbe essere più lunga del carattere originale.

Viene restituito il primo punto di codice della versione maiuscola (ma nota, come spiegato
appena sopra, che potrebbero essercene di più.)

Si presume che il carattere di input in "p" sia ben formato.

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

Carattere classificazione

Questa sezione riguarda le funzioni (in realtà le macro) che classificano i caratteri in tipi, come
come punteggiatura contro alfabetico, ecc. La maggior parte di questi sono analoghi all'espressione regolare
classi di caratteri. (Vedi "Classi di caratteri POSIX" in perlrecharclass.) Ce ne sono diversi
varianti per ogni classe. (Non tutte le macro hanno tutte le varianti; ogni elemento sotto elenca le
quelli validi per questo.) Nessuno è interessato da "use bytes", e solo quelli con "LC" nel
nome sono influenzati dalla locale corrente.

La funzione di base, ad esempio "isALPHA()", accetta un ottetto (un "char" o un "U8") come input
e restituisce un booleano se il carattere rappresentato da quell'ottetto è o meno (o
su piattaforme non ASCII, corrisponde a) un carattere ASCII nella classe denominata basata su
piattaforma, regole Unicode e Perl. Se l'input è un numero che non rientra in un ottetto,
Viene restituito FALSE.

La variante "isFOO_A" (es. "isALPHA_A()") è identica alla funzione di base senza suffisso
"_UN".

La variante "isFOO_L1" impone il set di caratteri Latin-1 (o EBCDIC equivlalent) al
piattaforma. Cioè, i punti di codice che sono ASCII non sono interessati, poiché ASCII è un sottoinsieme
di latino-1. Ma i punti di codice non ASCII vengono trattati come se fossero caratteri Latin-1.
Ad esempio, "isWORDCHAR_L1()" restituirà true quando viene chiamato con il punto di codice 0xDF,
che è un carattere di parola sia in ASCII che in EBCDIC (sebbene rappresenti diverso
caratteri in ciascuno).

La variante "isFOO_uni" è come la variante "isFOO_L1", ma accetta qualsiasi punto di codice UV come
ingresso. Se il punto di codice è maggiore di 255, vengono utilizzate le regole Unicode per determinare se lo è
nella classe dei personaggi. Per esempio, "èWORDCHAR_uni(0x100)" restituisce TRUE, poiché 0x100 è
LETTERA LATINA A MAIUSCOLA CON MACRON in Unicode, ed è un carattere di parola.

La variante "isFOO_utf8" è come "isFOO_uni", ma l'input è un puntatore a un (noto per essere
ben formato) stringa con codifica UTF-8 ("U8*" o "char*"). La classificazione dei soli
viene testato il primo carattere (possibilmente multibyte) nella stringa.

La variante "isFOO_LC" è come le varianti "isFOO_A" e "isFOO_L1", ma il risultato è basato
sulla locale corrente, che è ciò che significa "LC" nel nome. Se Perl può determinare
che la locale corrente è una locale UTF-8, utilizza le regole Unicode pubblicate; altrimenti,
utilizza la funzione della libreria C che fornisce la classificazione denominata. Per esempio,
"isDIGIT_LC()" quando non è in una locale UTF-8 restituisce il risultato della chiamata "isdigit()".
FALSE viene sempre restituito se l'input non rientra in un ottetto. Su alcune piattaforme dove
la funzione della libreria C è nota per essere difettosa, Perl cambia il suo risultato per seguire il
Regole dello standard POSIX.

La variante "isFOO_LC_uvchr" è come "isFOO_LC", ma è definita su qualsiasi UV. Restituisce il
uguale a "isFOO_LC" per i punti di codice di input inferiori a 256 e restituisce l'hard-coded, non-
affetto da locale, risultati Unicode per quelli più grandi.

La variante "isFOO_LC_utf8" è come "isFOO_LC_uvchr", ma l'input è un puntatore a un (noto
essere ben formato) stringa codificata in UTF-8 ("U8*" o "char*"). La classificazione di just
viene testato il primo carattere (possibilmente multibyte) nella stringa.

isALPHA Restituisce un booleano che indica se il carattere specificato è un carattere alfabetico
carattere, analogo a "m/[[:alpha:]]/". Vedere la parte superiore di questa sezione per an
spiegazione delle varianti "isALPHA_A", "isALPHA_L1", "isALPHA_uni", "isALPHA_utf8",
"isALPHA_LC", "isALPHA_LC_uvchr" e "isALPHA_LC_utf8".

bool isALPHA(char ch)

è ALFANUMERICO
Restituisce un booleano che indica se il carattere specificato è un an
carattere alfabetico o cifra decimale, analogo a "m/[[:alnum:]]/". Vedi la parte superiore
di questa sezione per una spiegazione delle varianti "isALPHANUMERIC_A",
"isALPHANUMERIC_L1", "isALPHANUMERIC_uni", "isALPHANUMERIC_utf8",
"isALPHANUMERIC_LC", "isALPHANUMERIC_LC_uvchr" e "isALPHANUMERIC_LC_utf8".

bool èALFANUMERICO(char ch)

isASCII Restituisce un booleano che indica se il carattere specificato è uno dei 128
caratteri nel set di caratteri ASCII, analogo a "m/[[:ascii:]]/". su non-
Piattaforme ASCII, restituisce TRUE se questo carattere corrisponde a un ASCII
carattere. Le varianti "isASCII_A()" e "isASCII_L1()" sono identiche a
"isASCII()". Vedere la parte superiore di questa sezione per una spiegazione delle varianti
"isASCII_uni", "isASCII_utf8", "isASCII_LC", "isASCII_LC_uvchr" e
"isASCII_LC_utf8". Nota, tuttavia, che alcune piattaforme non hanno la libreria C
routine "isascii()". In questi casi, le varianti i cui nomi contengono "LC" sono
gli stessi dei corrispondenti senza.

Si noti inoltre che, poiché tutti i caratteri ASCII sono invarianti UTF-8 (nel senso che
hanno la stessa identica rappresentazione (sempre un singolo byte) se codificata in UTF-8
o no), "isASCII" darà i risultati corretti quando viene chiamato con qualsiasi byte in qualsiasi
stringa codificata o meno in UTF-8. E allo stesso modo "isASCII_utf8" funzionerà correttamente
su qualsiasi stringa codificata o meno in UTF-8.

bool isASCII(char ch)

isBLANK Restituisce un booleano che indica se il carattere specificato è un carattere
considerato uno spazio vuoto, analogo a "m/[[:blank:]]/". Guarda la parte superiore di questo
sezione per una spiegazione delle varianti "isBLANK_A", "isBLANK_L1", "isBLANK_uni",
"isBLANK_utf8", "isBLANK_LC", "isBLANK_LC_uvchr" e "isBLANK_LC_utf8". Nota,
tuttavia, alcune piattaforme non hanno la routine della libreria C "isblank()". In
questi casi, le varianti i cui nomi contengono "LC" sono le stesse del
quelli corrispondenti senza.

bool èVUOTO(char ch)

isCNTRL Restituisce un booleano che indica se il carattere specificato è un controllo
carattere, analogo a "m/[[:cntrl:]]/". Vedere la parte superiore di questa sezione per an
spiegazione delle varianti "isCNTRL_A", "isCNTRL_L1", "isCNTRL_uni", "isCNTRL_utf8",
"isCNTRL_LC", "isCNTRL_LC_uvchr" e "isCNTRL_LC_utf8" Sulle piattaforme EBCDIC,
quasi sempre vogliono usare la variante "isCNTRL_L1".

bool isCNTRL(char ch)

isDIGIT Restituisce un booleano che indica se il carattere specificato è una cifra, analogo
a "m/[[:digit:]]/". Le varianti "isDIGIT_A" e "isDIGIT_L1" sono identiche a
"isDIGIT". Vedere la parte superiore di questa sezione per una spiegazione delle varianti
"isDIGIT_uni", "isDIGIT_utf8", "isDIGIT_LC", "isDIGIT_LC_uvchr" e
"isDIGIT_LC_utf8".

bool isDIGIT(char ch)

isGRAPH Restituisce un booleano che indica se il carattere specificato è un grafico
carattere, analogo a "m/[[:graph:]]/". Vedere la parte superiore di questa sezione per an
spiegazione delle varianti "isGRAPH_A", "isGRAPH_L1", "isGRAPH_uni", "isGRAPH_utf8",
"isGRAPH_LC", "isGRAPH_LC_uvchr" e "isGRAPH_LC_utf8".

bool isGRAPH(char ch)

èIDCONT
Restituisce un booleano che indica se il carattere specificato può essere il secondo o
carattere successivo di un identificatore. Questo è molto vicino, ma non proprio il
uguale alla proprietà Unicode ufficiale "XID_Continue". La differenza è che questo
restituisce true solo se il carattere di input corrisponde anche a "isWORDCHAR". Vedi la parte superiore
di questa sezione per una spiegazione delle varianti "isIDCONT_A", "isIDCONT_L1",
"isIDCONT_uni", "isIDCONT_utf8", "isIDCONT_LC", "isIDCONT_LC_uvchr" e
"isIDCONT_LC_utf8".

bool isIDCONT(char ch)

è IDFIRST
Restituisce un booleano che indica se il carattere specificato può essere il primo
carattere di un identificatore. Questo è molto vicino, ma non proprio come il
proprietà ufficiale Unicode "XID_Start". La differenza è che questo restituisce true
solo se il carattere di input corrisponde anche a "isWORDCHAR". Guarda la parte superiore di questo
sezione per una spiegazione delle varianti "isIDFIRST_A", "isIDFIRST_L1",
"isIDFIRST_uni", "isIDFIRST_utf8", "isIDFIRST_LC", "isIDFIRST_LC_uvchr" e
"isIDFIRST_LC_utf8".

bool isIDFIRST(char ch)

isLOWER Restituisce un booleano che indica se il carattere specificato è minuscolo
carattere, analogo a "m/[[:lower:]]/". Vedere la parte superiore di questa sezione per an
spiegazione delle varianti "isLOWER_A", "isLOWER_L1", "isLOWER_uni", "isLOWER_utf8",
"isLOWER_LC", "isLOWER_LC_uvchr" e "isLOWER_LC_utf8".

bool èINFERIORE(char ch)

isOCTAL Restituisce un booleano che indica se il carattere specificato è una cifra ottale,
[0-7]. Le uniche due varianti sono "isOCTAL_A" e "isOCTAL_L1"; ognuno è identico
su "isOCTAL".

bool isOCTAL(char ch)

isPRINT Restituisce un booleano che indica se il carattere specificato è stampabile
carattere, analogo a "m/[[:print:]]/". Vedere la parte superiore di questa sezione per an
spiegazione delle varianti "isPRINT_A", "isPRINT_L1", "isPRINT_uni", "isPRINT_utf8",
"isPRINT_LC", "isPRINT_LC_uvchr" e "isPRINT_LC_utf8".

bool isPRINT(char ch)

è PSXSPC
(abbreviazione di Posix Space) A partire dalla 5.18, questo è identico in tutte le sue forme a
le corrispondenti macro "isSPACE()". Le forme locali di questa macro sono
identici ai corrispondenti moduli "isSPACE()" in tutte le versioni di Perl. In
versioni precedenti alla 5.18, le forme non locali differiscono dalle loro forme "isSPACE()"
solo in quanto i moduli "isSPACE()" non corrispondono a una scheda verticale e il
I moduli "isPSXSPC()" lo fanno. Altrimenti sono identici. Quindi questa macro è
analogo a ciò che "m/[[:space:]]/" corrisponde in un'espressione regolare. Vedi la parte superiore
di questa sezione per una spiegazione delle varianti "isPSXSPC_A", "isPSXSPC_L1",
"isPSXSPC_uni", "isPSXSPC_utf8", "isPSXSPC_LC", "isPSXSPC_LC_uvchr" e
"isPSXSPC_LC_utf8".

bool isPSXSPC(char ch)

isPUNCT Restituisce un booleano che indica se il carattere specificato è una punteggiatura
carattere, analogo a "m/[[:punct:]]/". Nota che la definizione di cosa è
la punteggiatura non è così semplice come si potrebbe desiderare. Vedi "Carattere POSIX
Classi" in perlrecharclass per i dettagli. Vedi la parte superiore di questa sezione per un
spiegazione delle varianti "isPUNCT_A", "isPUNCT_L1", "isPUNCT_uni", "isPUNCT_utf8",
"isPUNCT_LC", "isPUNCT_LC_uvchr" e "isPUNCT_LC_utf8".

bool isPUNCT(char ch)

isSPACE Restituisce un booleano che indica se il carattere specificato è uno spazio bianco
carattere. Questo è analogo a ciò che "m/\s/" corrisponde in un'espressione regolare.
A partire da Perl 5.18 questo corrisponde anche a ciò che fa "m/[[:space:]]/". Precedente a
5.18, solo le forme locali di questa macro (quelle con "LC" nel nome)
corrispondeva esattamente a ciò che fa "m/[[:space:]]/". In quelle versioni, l'unico
la differenza, nelle varianti non locali, era che "isSPACE()" non corrispondeva a a
scheda verticale. (Vedi "isPSXSPC" per una macro che corrisponda a una scheda verticale in tutto
versioni.) Vedere la parte superiore di questa sezione per una spiegazione delle varianti
"isSPACE_A", "isSPACE_L1", "isSPACE_uni", "isSPACE_utf8", "isSPACE_LC",
"isSPACE_LC_uvchr" e "isSPACE_LC_utf8".

bool èSPACE(char ch)

isUPPER Restituisce un booleano che indica se il carattere specificato è maiuscolo
carattere, analogo a "m/[[:upper:]]/". Vedere la parte superiore di questa sezione per an
spiegazione delle varianti "isUPPER_A", "isUPPER_L1", "isUPPER_uni", "isUPPER_utf8",
"isUPPER_LC", "isUPPER_LC_uvchr" e "isUPPER_LC_utf8".

bool isUPPER(char ch)

èWORDCHAR
Restituisce un booleano che indica se il carattere specificato è un carattere che
è un carattere di parola, analogo a ciò che "m/\w/" e "m/[[:word:]]/" corrispondono in un
espressione regolare. Un carattere di parola è un carattere alfabetico, una cifra decimale,
un carattere di punteggiatura di collegamento (come un carattere di sottolineatura) o un carattere "segno"
che si attacca a uno di quelli (come una sorta di accento). "isALNUM()" è un
sinonimo fornito per compatibilità con le versioni precedenti, anche se il carattere di una parola include
più del significato del linguaggio C standard di alfanumerico. Guarda la parte superiore di questo
sezione per una spiegazione delle varianti "isWORDCHAR_A", "isWORDCHAR_L1",
"isWORDCHAR_uni" e "isWORDCHAR_utf8". "isWORDCHAR_LC", "isWORDCHAR_LC_uvchr",
e "isWORDCHAR_LC_utf8" sono anche come descritti lì, ma includono inoltre il
carattere di sottolineatura nativo della piattaforma.

bool isWORDCHAR(char ch)

èXDIGIT
Restituisce un booleano che indica se il carattere specificato è esadecimale
cifra. Nella gamma ASCII questi sono "[0-9A-Fa-f]". Varianti "isXDIGIT_A()" e
"isXDIGIT_L1()" sono identici a "isXDIGIT()". Vedere la parte superiore di questa sezione per an
spiegazione delle varianti "isXDIGIT_uni", "isXDIGIT_utf8", "isXDIGIT_LC",
"isXDIGIT_LC_uvchr" e "isXDIGIT_LC_utf8".

bool èXDIGIT(char ch)

Clonazione an interprete

perl_clone
Crea e restituisci un nuovo interprete clonando quello attuale.

perl_clone prende questi flag come parametri:

CLONEf_COPY_STACKS - è abituato, beh, a copiare anche gli stack, senza di esso solo noi
clonare i dati e azzerare gli stack, con esso si copiano gli stack e il nuovo perl
l'interprete è pronto per essere eseguito esattamente nello stesso punto del precedente. Il
il codice pseudo-fork usa COPY_STACKS mentre threads->create no.

CLONEf_KEEP_PTR_TABLE - perl_clone mantiene una ptr_table con il puntatore del vecchio
variabile come chiave e la nuova variabile come valore, questo gli consente di verificare se
qualcosa è stato clonato e non clonarlo di nuovo, ma piuttosto usa semplicemente il valore e
aumentare il refcount. Se KEEP_PTR_TABLE non è impostato, perl_clone ucciderà il
ptr_table utilizzando la funzione "ptr_table_free(PL_ptr_table); PL_ptr_table = NULL;",
il motivo per tenerlo in giro è se vuoi duplicare alcune delle tue variabili che sono
al di fuori del grafico perl scans, l'esempio di questo codice è in threads.xs create.

CLONEf_CLONE_HOST - Questa è una cosa win32, viene ignorata su Unix, dice a perls
codice win32host (che è c++) per clonare se stesso, questo è necessario su win32 se lo desideri
per eseguire due thread contemporaneamente, se vuoi solo fare alcune cose in un
interprete perl separato e poi buttarlo via e tornare a quello originale,
non devi fare nulla.

Interprete Perl* perl_clone(
Interprete Perl *proto_perl,
Bandiere UV
)

Tempo di compilazione portata ganci

BhkDISABILITA
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Disabilitare temporaneamente una voce in questa struttura BHK, cancellando l'appropriato
bandiera. quale è un token del preprocessore che indica quale voce disabilitare.

void BhkDISABLE(BHK *hk, che)

BhkABILITA
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Riattivare una voce in questa struttura BHK, impostando il flag appropriato. quale
è un token del preprocessore che indica quale voce abilitare. Questo affermerà (sotto
-DDEBUGGING) se la voce non contiene un puntatore valido.

void BhkENABLE(BHK *hk, che)

BhkENTRY_set
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Imposta una voce nella struttura BHK e imposta i flag per indicare che è valida.
quale è un token di pre-elaborazione che indica quale voce impostare. Il tipo di PTR
dipende dall'entrata

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

blockhook_register
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Registra una serie di hook da chiamare quando l'ambito lessicale di Perl cambia a
tempo di compilazione. Vedere "ganci dell'ambito in fase di compilazione" in perlguts.

NOTA: questa funzione deve essere chiamata esplicitamente come Perl_blockhook_register con an
aTHX_ parametro.

void Perl_blockhook_register(pTHX_ BHK *hk)

COP Suggerimento hash

coph_2hv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Genera e restituisce un hash Perl standard che rappresenta l'insieme completo di chiave/valore
coppie nel poliziotto suggerimenti hash coph. bandiere è attualmente inutilizzato e deve essere zero.

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

coph_copy
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Crea e restituisci una copia completa dell'hash dei suggerimenti per i poliziotti coph.

COPHH * cophh_copia(COPHH *cophh)

cophh_delete_pv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_delete_pvn", ma accetta una stringa con terminazione null invece di a
coppia stringa/lunghezza.

COPHH * cophh_delete_pv(const COPHH *cophh,
const char *chiave, hash U32,
bandiere U32)

cophh_delete_pvn
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Elimina una chiave e il suo valore associato dall'hash dei suggerimenti del poliziotto coph, e restituisce
l'hash modificato. Il puntatore hash restituito in generale non è lo stesso del
puntatore hash che è stato passato. L'hash di input viene consumato dalla funzione e
il puntatore ad esso non deve essere utilizzato successivamente. Usa "cophh_copy" se necessario
entrambi gli hash.

La chiave è specificata da chiave pv e a keylen. Se bandiere ha il bit "COPHH_KEY_UTF8"
set, gli ottetti chiave vengono interpretati come UTF-8, altrimenti vengono interpretati come
latino-1. hash è un hash precalcolato della stringa della chiave, o zero se non lo è stato
precalcolato.

COPHH * cophh_delete_pvn(COPHH *cophh,
const carattere *keypv,
STRLEN keylen, hash U32,
bandiere U32)

cophh_delete_pvs
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_delete_pvn", ma accetta una stringa letterale invece di una stringa/lunghezza
coppia e nessun hash precalcolato.

COPHH * cophh_delete_pvs(const COPHH *cophh,
const char *chiave, flag U32)

cophh_delete_sv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_delete_pvn", ma accetta uno scalare Perl invece di una coppia stringa/lunghezza.

COPHH * cophh_delete_sv(const COPHH *cophh, SV *chiave,
Hash U32, flag U32)

cophh_fetch_pv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_fetch_pvn", ma accetta una stringa con terminazione null invece di a
coppia stringa/lunghezza.

SV * cophh_fetch_pv(const COPHH *cophh,
const char *chiave, hash U32,
bandiere U32)

cophh_fetch_pvn
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Cerca la voce nell'hash dei suggerimenti per i poliziotti coph con la chiave specificata da chiave pv e a
keylen. Se bandiere ha il bit "COPHH_KEY_UTF8" impostato, gli ottetti chiave vengono interpretati
come UTF-8, altrimenti vengono interpretati come Latin-1. hash è un hash precalcolato
della stringa della chiave, o zero se non è stato precalcolato. Restituisce un mortale
copia scalare del valore associato alla chiave, o &PL_sv_placeholder se presente
non è un valore associato alla chiave.

SV * cophh_fetch_pvn(const COPHH *cophh,
const carattere *keypv,
STRLEN keylen, hash U32,
bandiere U32)

cophh_fetch_pvs
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_fetch_pvn", ma accetta una stringa letterale invece di una stringa/lunghezza
coppia e nessun hash precalcolato.

SV * cophh_fetch_pvs(const COPHH *cophh,
const char *chiave, flag U32)

cophh_fetch_sv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_fetch_pvn", ma accetta uno scalare Perl invece di una coppia stringa/lunghezza.

SV * cophh_fetch_sv(const COPHH *cophh, SV *chiave,
Hash U32, flag U32)

coph_free
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Scarta i suggerimenti del poliziotto hash coph, liberando tutte le risorse ad esso associate.

vuoto cophh_free(COPHH *cophh)

coph_new_empty
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Genera e restituisci un nuovo hash di suggerimenti per i poliziotti che non contiene voci.

COPHH * cophh_nuovo_vuoto()

cophh_store_pv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_store_pvn", ma accetta una stringa con terminazione null invece di a
coppia stringa/lunghezza.

COPHH * cophh_store_pv(const COPHH *cophh,
const char *chiave, hash U32,
SV *valore, flag U32)

cophh_store_pvn
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Memorizza un valore, associato a una chiave, nell'hash dei suggerimenti del poliziotto coph, e restituisce
l'hash modificato. Il puntatore hash restituito in generale non è lo stesso del
puntatore hash che è stato passato. L'hash di input viene consumato dalla funzione e
il puntatore ad esso non deve essere utilizzato successivamente. Usa "cophh_copy" se necessario
entrambi gli hash.

La chiave è specificata da chiave pv e a keylen. Se bandiere ha il bit "COPHH_KEY_UTF8"
set, gli ottetti chiave vengono interpretati come UTF-8, altrimenti vengono interpretati come
latino-1. hash è un hash precalcolato della stringa della chiave, o zero se non lo è stato
precalcolato.

APPREZZIAMO è il valore scalare da memorizzare per questa chiave. APPREZZIAMO è copiato da questo
funzione, che quindi non si appropria di alcun riferimento ad essa, e successivamente
le modifiche allo scalare non si rifletteranno nel valore visibile nei suggerimenti del poliziotto
hash. I tipi complessi di scalare non verranno archiviati con integrità referenziale, ma
sarà costretto alle stringhe.

COPHH * cophh_store_pvn(COPHH *cophh, const char *keypv,
STRLEN keylen, hash U32,
SV *valore, flag U32)

cophh_store_pvs
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_store_pvn", ma accetta una stringa letterale invece di una stringa/lunghezza
coppia e nessun hash precalcolato.

COPHH * cophh_store_pvs(const COPHH *cophh,
const char *chiave, SV *valore,
bandiere U32)

cophh_store_sv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "cophh_store_pvn", ma accetta uno scalare Perl invece di una coppia stringa/lunghezza.

COPHH * cophh_store_sv(const COPHH *cophh, SV *chiave,
Hash U32, SV *valore, flag U32)

COP Suggerimento Lettura

cop_suggerimenti_2hv
Genera e restituisce un hash Perl standard che rappresenta l'intero set di suggerimenti
voci in poliziotto poliziotto. bandiere è attualmente inutilizzato e deve essere zero.

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

cop_hints_fetch_pv
Come "cop_hints_fetch_pvn", ma accetta una stringa con terminazione null invece di a
coppia stringa/lunghezza.

SV * cop_hints_fetch_pv(const COP *poliziotto,
const char *chiave, hash U32,
bandiere U32)

cop_hints_fetch_pvn
Cerca la voce del suggerimento nel poliziotto poliziotto con la chiave specificata da chiave pv e a keylen.
If bandiere ha il bit "COPHH_KEY_UTF8" impostato, gli ottetti chiave vengono interpretati come
UTF-8, altrimenti vengono interpretati come Latin-1. hash è un hash precalcolato di
la stringa della chiave o zero se non è stata precalcolata. Restituisce uno scalare mortale
copia del valore associato alla chiave, o &PL_sv_placeholder se non c'è
valore associato alla chiave.

SV * cop_hints_fetch_pvn(const COP *poliziotto,
const carattere *keypv,
STRLEN keylen, hash U32,
bandiere U32)

cop_hints_fetch_pvs
Come "cop_hints_fetch_pvn", ma accetta una stringa letterale invece di una stringa/lunghezza
coppia e nessun hash precalcolato.

SV * cop_hints_fetch_pvs(const COP *poliziotto,
const char *chiave, flag U32)

cop_hints_fetch_sv
Come "cop_hints_fetch_pvn", ma accetta uno scalare Perl invece di una stringa/lunghezza
coppia.

SV * cop_hints_fetch_sv(const COP *cop, SV *chiave,
Hash U32, flag U32)

Custom Operatori

registro_op_personalizzato
Registra un'operazione personalizzata. Vedi "Operatori personalizzati" in perlguts.

NOTA: questa funzione deve essere chiamata esplicitamente come Perl_custom_op_register con an
aTHX_ parametro.

void Perl_custom_op_register(pTHX_
Perl_ppaddr_t paddr,
cost XOP *xop)

custom_op_xop
Restituisce la struttura XOP per una determinata operazione personalizzata. Questa macro dovrebbe essere considerata
interna a OP_NAME e alle altre macro di accesso: usale invece. Questa macro
chiama una funzione Prima del 5.19.6, questo era implementato come funzione.

NOTA: questa funzione deve essere chiamata esplicitamente come Perl_custom_op_xop con aTHX_
parametro.

const XOP * Perl_custom_op_xop(pTHX_ const OP *o)

XopDISABILITA
Disabilitare temporaneamente un membro dell'XOP, deselezionando il flag appropriato.

void XopDISABLE(XOP *xop, che)

XapENABLE
Riabilitare un membro dell'XOP che è stato disabilitato.

void XopENABLE(XOP *xop, che)

XopenENTRY
Restituisce un membro della struttura XOP. quale è un token cpp che indica quale voce
ritornare. Se il membro non è impostato, restituirà un valore predefinito. Il ritorno
il tipo dipende da quale. Questa macro valuta i suoi argomenti più di una volta. Se tu
stanno usando "Perl_custom_op_xop" per recuperare un "XOP *" da un "OP *", usa più
efficiente "XopENTRYCUSTOM" invece.

XopENTRY(XOP *xop, che)

XopENTRYCUSTOM
Esattamente come "XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_o), which)" ma più
efficiente. Il quale parametro è identico a "XopENTRY".

XopENTRYCUSTOM(const OP *o, che)

XopenENTRY_set
Imposta un membro della struttura XOP. quale è un token cpp che indica a quale voce
impostato. Vedi "Operatori personalizzati" in perlguts per i dettagli sui membri disponibili
e come vengono utilizzati. Questa macro valuta il suo argomento più di una volta.

void XopENTRY_set(XOP *xop, che, valore)

XopFLAG
Restituisci le bandiere dell'XOP.

U32 XopFLAGS(XOP *xop)

CV Manipolazione funzioni

Questa sezione documenta le funzioni per manipolare i CV che sono valori di codice o subroutine.
Per ulteriori informazioni, vedere perlguts.

chiamante_cx
L'equivalente di XSUB-writer di chiamante(). La struttura "PERL_CONTEXT" restituita
può essere interrogato per trovare tutte le informazioni restituite a Perl dal "chiamante".
Nota che gli XSUB non ottengono uno stack frame, quindi "caller_cx(0, NULL)" restituirà
informazioni per il codice Perl immediatamente circostante.

Questa funzione salta le chiamate automatiche a &DB::sub effettuate per conto del
debugger. Se lo stack frame richiesto era un sub chiamato da "DB::sub", il ritorno
value sarà il frame per la chiamata a "DB::sub", poiché ha la riga corretta
numero/ecc. per il sito della chiamata. Se dbcxp non è "NULL", sarà impostato su a
puntatore al frame per la sottochiamata stessa.

const PERL_CONTEXT * chiamante_cx(
livello I32,
const PERL_CONTEXT **dbcxp
)

CvSTASH Restituisce la scorta del CV. Una scorta è l'hash della tabella dei simboli, che contiene il
variabili nell'ambito del pacchetto nel pacchetto in cui è stata definita la subroutine. Per
maggiori informazioni, vedere perlguts.

Questo ha anche un uso speciale con i sub XS AUTOLOAD. Vedere "Caricamento automatico con XSUB"
in perlgut.

HV* CvSTASH(CV* cv)

trova_runcv
Individua il CV corrispondente al sub o eval attualmente in esecuzione. Se db_seqp è
non_null, salta i CV che si trovano nel pacchetto DB e popola *db_seqp con il cop
numero di sequenza nel punto in cui è stato inserito il codice DB::. (Questo permette
debugger per eval nell'ambito del punto di interruzione piuttosto che nell'ambito del
debugger stesso.)

CV* find_runcv(U32 *db_seqp)

get_cv Usa "strlen" per ottenere la lunghezza di "name", quindi chiama "get_cvn_flags".

NOTA: la forma perl_ di questa funzione è deprecata.

CV* get_cv(const char* nome, flag I32)

get_cvn_flags
Restituisce il CV della subroutine Perl specificata. le "bandiere" sono passate a
"gv_fetchpvn_flags". Se "GV_ADD" è impostato e la subroutine Perl non esiste
quindi verrà dichiarato (che ha lo stesso effetto di dire "sub name;"). Se
"GV_ADD" non è impostato e la subroutine non esiste, quindi viene restituito NULL.

NOTA: la forma perl_ di questa funzione è deprecata.

CV* get_cvn_flags(const char* nome, STRLEN len,
bandiere I32)

Debug Elettricita, Gas Ed Acqua

discarica_tutto
Scarica l'intero optree del programma corrente a partire da "PL_main_root" in
"STDER". Scarica anche le opzioni per tutte le subroutine visibili in "PL_defstash".

vuoto dump_all()

dump_packsubs
Scarica le opzioni per tutte le subroutine visibili in "stash".

void dump_packsubs(const HV* scorta)

op_dump Scarica l'optree a partire da OP "o" in "STDERR".

void op_dump(const OP *o)

sv_dump Scarica il contenuto di un SV nel filehandle "STDERR".

Per un esempio del suo output, vedere Devel::Peek.

void sv_dump(SV* sv)

Dsiplay e a Scaricare funzioni

pv_display
Simile a

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

tranne che un ulteriore "\0" verrà aggiunto alla stringa quando len > cur e
pv[cur] è "\0".

Nota che la stringa finale può essere fino a 7 caratteri più lunga di pvlim.

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

pv_escape
Sfugge al massimo i primi "count" caratteri di pv e mette i risultati in dsv tale
che la dimensione della stringa di escape non supererà "max" caratteri e non sarà
contenere sequenze di escape incomplete. Il numero di byte sfuggiti sarà
restituito nel parametro STRLEN *escaped se non è null. Quando il dsv
parametro è null non si verifica effettivamente l'escape, ma il numero di byte che sarebbe
essere sfuggito se non nullo verrà calcolato.

Se i flag contengono PERL_PV_ESCAPE_QUOTE, allora qualsiasi virgoletta nella stringa lo farà
anche essere fuggito.

Normalmente l'SV verrà cancellato prima che la stringa di escape sia preparata, ma quando
PERL_PV_ESCAPE_NOCLEAR è impostato che non si verificherà.

Se PERL_PV_ESCAPE_UNI è impostato, la stringa di input viene trattata come UTF-8 se
PERL_PV_ESCAPE_UNI_DETECT è impostato, quindi la stringa di input viene scansionata usando
"is_utf8_string()" per determinare se è UTF-8.

Se PERL_PV_ESCAPE_ALL è impostato, tutti i caratteri di input verranno emessi utilizzando "\x01F1"
lo stile esegue l'escape, altrimenti se PERL_PV_ESCAPE_NONASCII è impostato, solo i caratteri non ASCII
sarà sfuggito usando questo stile; in caso contrario, solo i caratteri superiori a 255 saranno così
sfuggito; altri caratteri non stampabili utilizzeranno modelli di escape ottali o comuni come
"\n". Altrimenti, se PERL_PV_ESCAPE_NOBACKSLASH allora tutti i caratteri sotto 255 saranno
trattata come stampabile e verrà emessa come letterale.

Se PERL_PV_ESCAPE_FIRSTCHAR è impostato, solo il primo carattere della stringa sarà
sfuggito, indipendentemente da max. Se l'output deve essere in esadecimale, allora sarà
restituito come una semplice sequenza esadecimale. Quindi l'output sarà un singolo carattere,
una sequenza di escape ottale, un escape speciale come "\n" o un valore esadecimale.

Se PERL_PV_ESCAPE_RE è impostato, il carattere di escape utilizzato sarà un '%' e non un
'\\'. Questo perché le espressioni regolari contengono molto spesso sequenze con barra rovesciata, mentre
'%' non è un carattere particolarmente comune nei modelli.

Restituisce un puntatore al testo con escape come tenuto da dsv.

char* pv_escape(SV *dsv, char const * const str,
const STRLEN conteggio, const STRLEN max,
STRLEN * const fuggito,
const bandiere U32)

pv_abbastanza
Converte una stringa in qualcosa di presentabile, gestendo l'escape tramite pv_escape()
e supporto di citazioni ed ellissi.

Se il flag PERL_PV_PRETTY_QUOTE è impostato, il risultato sarà tra virgolette doppie con
eventuali virgolette doppie nella stringa sono sfuggite. Altrimenti se PERL_PV_PRETTY_LTGT
flag è impostato, quindi il risultato viene racchiuso tra parentesi angolari.

Se il flag PERL_PV_PRETTY_ELLIPSES è impostato e non tutti i caratteri nella stringa erano
output quindi un'ellissi "..." verrà aggiunta alla stringa. Nota che questo
succede DOPO che è stato citato.

Se start_colorènon-null allora saràinserito dopo la virgoletta di apertura (se
ce n'è uno) ma prima del testo sfuggito. Se end_color non è null, lo farà
essere inserito dopo il testo di escape ma prima di eventuali virgolette o puntini di sospensione.

Restituisce un puntatore al testo abbellito come tenuto da dsv.

char* pv_pretty(SV *dsv, char const * const str,
const STRLEN conteggio, const STRLEN max,
char const * const start_color,
char const * const end_color,
const bandiere U32)

Incorporare funzioni

cv_clone
Clonare un CV, facendo una chiusura lessicale. proto fornisce il prototipo del
funzione: il suo codice, la struttura del pad e altri attributi. Il prototipo è
combinato con una cattura di lessicali esterni a cui il codice fa riferimento, che sono
preso dall'istanza attualmente in esecuzione del codice immediatamente circostante.

CV * cv_clone(CV *prototipo)

cv_name Restituisce un SV contenente il nome del CV, principalmente da utilizzare nella segnalazione degli errori.
Il CV potrebbe invece essere effettivamente un GV, nel qual caso l'SV restituito contiene i GV
nome. Qualsiasi cosa diversa da un GV o CV viene trattata come una stringa che già contiene il
nome secondario, ma questo potrebbe cambiare in futuro.

Un SV può essere passato come secondo argomento. In tal caso, gli verrà assegnato il nome
e sarà restituito. In caso contrario, il SV restituito sarà un nuovo mortale.

Se l' bandiere includi CV_NAME_NOTQUAL, il nome del pacchetto non sarà incluso.
Se il primo argomento nonè né un CV né un GV, questo flag viene ignorato (soggetto a
modificare).

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

cv_undef
Cancella tutti i componenti attivi di un CV. Questo può accadere sia da un
esplicito "undef &foo", o dal conteggio dei riferimenti che va a zero. Nella prima
caso, manteniamo il puntatore CvOUTSIDE, in modo che eventuali bambini anonimi possano ancora
seguire l'intera catena dell'ambito lessicale.

void cv_undef(CV* cv)

trova_rundefsv
Trova e restituisce la variabile denominata $_ nell'ambito lessicale del
funzione attualmente in esecuzione. Questo potrebbe essere un $_ lessicale, o altrimenti sarà il
quello globale.

SV * trova_rundefsv()

find_rundefsvoffset
DEPRECATO! Si prevede di rimuovere questa funzione da una futura versione di Perl.
Non usarlo per il nuovo codice; rimuoverlo dal codice esistente.

Trova la posizione del lessico $_ nel pad dell'attuale esecuzione
funzione. Restituisce l'offset nel pad corrente, o "NOT_IN_PAD" se non c'è
lessicale $_ nell'ambito (nel qual caso dovrebbe essere usato quello globale).
"find_rundefsv" è probabilmente più conveniente.

NOTA: la forma perl_ di questa funzione è deprecata.

PADOFFSET trova_rundefsvoffset()

introduzione_mia
"Introduci" le "mie" variabili allo stato visibile. Questo viene chiamato durante l'analisi at
la fine di ogni istruzione per rendere visibili le variabili lessicali ai successivi
dichiarazioni.

U32 intro_mio()

carico_modulo
Carica il modulo il cui nome è puntato dalla parte stringa di name. Notare che
dovrebbe essere fornito il nome del modulo effettivo, non il nome del file. Ad esempio, "Foo::Bar" invece
di "Foo/Bar.pm". i flag possono essere PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT o
PERL_LOADMOD_IMPORT_OPS (o 0 per nessun flag). ver, se specificato e non NULL,
fornisce una semantica di versione simile a "usa Foo::Bar VERSION". L'opzionale
gli argomenti finali SV* possono essere usati per specificare gli argomenti del modulo importare()
simile a "usa Foo::Bar ELENCO VERSIONI". Devono essere terminati con a
puntatore NULL finale. Nota che questo elenco può essere omesso solo quando il
È stato utilizzato il flag PERL_LOADMOD_NOIMPORT. Altrimenti almeno un singolo NULL
è richiesto il puntatore per designare l'elenco di importazione predefinito.

Il conteggio dei riferimenti per ogni parametro "SV*" specificato viene decrementato.

void load_module (flag U32, nome SV*, versione SV*, ...)

nuovoPADNAMELIST
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Crea un nuovo elenco di nomi di pad. "max" è l'indice più alto per il quale lo spazio è
assegnato.

PADNAMELIST * newPADNAMELIST (dimensione_t max)

nuovoPADNAMEesterno
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Costruisce e restituisce un nuovo nome di pad. Utilizzare questa funzione solo per i nomi che
fare riferimento a lessici esterni. (Vedi anche "nuovoPADNAMEpvn".) esterno è il nome del pad esterno
che questo rispecchia. Il nome del pad restituito ha già il flag PADNAMEt_OUTER
impostato.

PADNAME * nuovoPADNAMEouter(PADNAME *esterno)

nuovoPADNAMEpvn
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Costruisce e restituisce un nuovo nome di pad. s deve essere una stringa UTF8. Non usare questo
per i nomi di pad che puntano a lessicali esterni. Vedere "nuovoPADNAMEesterno".

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

notthreadhook
Stub che fornisce hook di thread per perl_destruct quando non ci sono thread.

int notthreadhook()

padnamelist_fetch
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Recupera il nome del pad dall'indice specificato.

PADNAME * padnamelist_fetch(PADNAMELIST *pnl,
Ssize_t chiave)

padnamelist_store
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Memorizza il nome del pad (che può essere nullo) all'indice dato, liberando qualsiasi esistente
nome del pad in quello slot.

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

pad_add_anon
Assegna un posto nel pad attualmente in fase di compilazione (tramite "pad_alloc") per an
funzione anonima con ambito lessicale all'interno della compilazione attualmente in corso
funzione. La funzione func è collegato al pad e il suo collegamento "CvOUTSIDE" a
l'ambito esterno è indebolito per evitare un loop di riferimento.

Un conteggio dei riferimenti è stato rubato, quindi potrebbe essere necessario eseguire "SvREFCNT_inc(func)".

tipo ottuso dovrebbe essere un codice operativo che indica il tipo di operazione che la voce pad è
supportare. Ciò non influisce sulla semantica operativa, ma viene utilizzato per il debug.

PADOFFSET pad_add_anon(CV *funzione, tipo I32)

pad_aggiungi_nome_pv
Esattamente come "pad_add_name_pvn", ma accetta una stringa con terminazione null invece di a
coppia stringa/lunghezza.

PADOFFSET pad_add_name_pv(const char *name, flag U32,
HV *dattiloscritto, HV *dattaceo)

pad_add_name_pvn
Assegna un posto nel pad in fase di compilazione per una variabile lessicale denominata.
Memorizza il nome e altri metadati nella parte del nome del pad e rende
preparativi per gestire l'ambito lessicale della variabile. Restituisce l'offset di
slot pad assegnato.

nomepv/namelen specificare il nome della variabile, compreso il sigillo iniziale. Se dattilografare
non è null, il nome è per un lessico tipizzato e questo identifica il tipo. Se
la nostra scorta non è null, è un riferimento lessicale a una variabile del pacchetto e questo
identifica il pacco. I seguenti flag possono essere combinati con OR:

padadd_OUR specifica in modo ridondante se è un pacchetto var
La variabile padadd_STATE manterrà il valore in modo persistente
padadd_NO_DUP_CHECK salta il controllo dell'ombra lessicale

PADOFFSET pad_add_name_pvn(const char *namepv,
Nome STRLEN, bandiere U32,
HV *dattiloscritto, HV *dattaceo)

pad_add_name_sv
Esattamente come "pad_add_name_pvn", ma prende la stringa del nome sotto forma di SV
invece di una coppia stringa/lunghezza.

PADOFFSET pad_add_name_sv(SV *name, flag U32,
HV *dattiloscritto, HV *dattaceo)

pad_alloc
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Assegna un posto nel pad attualmente in fase di compilazione, restituendo l'offset di
slot pad assegnato. Nessun nome è inizialmente assegnato allo slot del pad. tipo è un
set di flag indicanti il ​​tipo di pad entry richiesto, che verrà impostato nel
valore SV per la voce pad assegnata:

SVs_PADMY variabile lessicale denominata ("mio", "nostro", "stato")
SVs_PADTMP negozio temporaneo senza nome
SVf_READONLY costante condivisa tra i livelli di ricorsione

"SVf_READONLY" è stato supportato qui solo da perl 5.20. Per lavorare con prima
anche le versioni, usa "SVf_READONLY|SVs_PADTMP". "SVf_READONLY" non causa
l'SV nello slot del pad deve essere contrassegnato come di sola lettura, ma dice semplicemente a "pad_alloc" che
it andrete a essere reso di sola lettura (dal chiamante), o almeno dovrebbe essere trattato come tale.

tipo ottuso dovrebbe essere un codice operativo che indica il tipo di operazione che la voce pad è
supportare. Ciò non influisce sulla semantica operativa, ma viene utilizzato per il debug.

PADOFFSET pad_alloc(I32 tipoop, U32 tipotmp)

pad_findmy_pv
Esattamente come "pad_findmy_pvn", ma accetta una stringa con terminazione null invece di a
coppia stringa/lunghezza.

PADOFFSET pad_findmy_pv(const char *name, flag U32)

pad_findmy_pvn
Dato il nome di una variabile lessicale, trova la sua posizione nell'attuale compilazione
tampone. nomepv/namelen specificare il nome della variabile, compreso il sigillo iniziale. bandiere
è riservato e deve essere zero. Se non è nel pad corrente ma appare nel
pad di qualsiasi ambito lessicalmente racchiuso, quindi viene aggiunta una pseudo-voce per esso nel
pad attuale. Restituisce l'offset nel pad corrente, o "NOT_IN_PAD" se non lo è
lessicale è nell'ambito.

PADOFFSET pad_findmy_pvn(const char *namepv,
STRLEN nomelen, bandiere U32)

pad_findmy_sv
Esattamente come "pad_findmy_pvn", ma prende la stringa del nome sotto forma di SV
invece di una coppia stringa/lunghezza.

PADOFFSET pad_findmy_sv(SV *nome, flag U32)

pad_setsv
Imposta il valore su offset po nel pad corrente (compilazione o esecuzione). Utilizzare il
macro PAD_SETSV() piuttosto che chiamare direttamente questa funzione.

void pad_setsv(PADOFFSET po, SV *sv)

pad_sv Ottieni il valore all'offset po nel pad corrente (compilazione o esecuzione). Usa macro
PAD_SV invece di chiamare direttamente questa funzione.

SV * pad_sv(PADOFFSETpo)

pad_ordinato
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Riordinare un pad al termine della compilazione del codice a cui appartiene. Lavori
eseguite qui sono: rimuovere la maggior parte delle cose dai pad dei prototipi anonsub; dagli
un @_; contrassegnare i temporanei come tali. Digitare indica il tipo di sottoprogramma:

padtidy_SUB subroutine ordinaria
padtidy_SUBCLONE prototipo per chiusura lessicale
formato padtidy_FORMAT

void pad_tidy(tipo padtidy_type)

perl_alloc
Assegna un nuovo interprete Perl. Vedi perlem.

Interprete Perl* perl_alloc()

perl_costrutto
Inizializza un nuovo interprete Perl. Vedi perlem.

void perl_construct(PerlInterpreter *my_perl)

perl_destruct
Chiude un interprete Perl. Vedi perlem.

int perl_destruct(PerlInterpreter *mio_perl)

perl_free
Rilascia un interprete Perl. Vedi perlem.

void perl_free(PerlInterpreter *my_perl)

perl_parse
Dice a un interprete Perl di analizzare uno script Perl. Vedi perlem.

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

perl_run
Dice a un interprete Perl di eseguire. Vedi perlem.

int perl_run(PerlInterpreter *mio_perl)

richiedono_pv
Dice a Perl di "richiedere" il file denominato dall'argomento stringa. È analogo a
il codice Perl "eval "require '$file'"". È persino implementato in questo modo; tenere conto
usando invece load_module.

NOTA: la forma perl_ di questa funzione è deprecata.

void require_pv(const char* pv)

Eccezione Manovrabilità (semplice) Macro

dXCPT Imposta le variabili locali necessarie per la gestione delle eccezioni. Vedere "Gestione delle eccezioni"
in perlgut.

dXCPT;

XCPT_CATCH
Introduce un blocco di cattura. Vedi "Gestione delle eccezioni" in perlguts.

XCPT_RETHROW
Rilancia un'eccezione rilevata in precedenza. Vedi "Gestione delle eccezioni" in perlguts.

XCPT_RETHROW;

XCPT_TRY_END
Termina un blocco di tentativi. Vedi "Gestione delle eccezioni" in perlguts.

XCPT_TRY_START
Avvia un blocco di prova. Vedi "Gestione delle eccezioni" in perlguts.

globali Variabili

Queste variabili sono globali per un intero processo. Sono condivisi tra tutti gli interpreti
e tutti i thread in un processo.

PL_verifica
Array, indicizzato da opcode, di funzioni che verranno richiamate per la fase di "verifica".
di optree build durante la compilazione del codice Perl. Per la maggior parte (ma non tutti) i tipi
di op, una volta che l'op è stato inizialmente creato e popolato con operazioni figlio, lo farà
essere filtrato attraverso la funzione di verifica referenziata dall'apposito elemento di
questa matrice. Il nuovo op viene passato come unico argomento alla funzione di controllo,
e la funzione di verifica restituisce l'operazione completata. La funzione di controllo può (come il
suggerisce il nome) verificare la validità dell'operazione e segnalare errori. Potrebbe anche
inizializzare o modificare parti delle operazioni o eseguire interventi chirurgici più radicali come
aggiungendo o rimuovendo operazioni secondarie, o addirittura eliminando l'operazione e restituendo un'operazione diversa
al suo posto.

Questa matrice di puntatori a funzione è un posto conveniente per agganciarsi alla compilazione
processi. Un modulo XS può mettere la propria funzione di controllo personalizzata al posto di qualsiasi di
quelli standard, per influenzare la compilazione di un particolare tipo di op.
Tuttavia, una funzione di verifica personalizzata non deve mai sostituire completamente una verifica standard
funzione (o anche una funzione di controllo personalizzata da un altro modulo). Un modulo
la modifica del controllo deve invece avvolgere la funzione di controllo preesistente. Un'usanza
la funzione di controllo deve essere selettiva su quando applicare il suo comportamento personalizzato. Nel
nel solito caso in cui decide di non fare nulla di speciale con un'operazione, deve concatenare
la funzione op preesistente. Le funzioni di controllo sono quindi collegate in una catena, con il
controllo di base del core alla fine.

Per la sicurezza dei thread, i moduli non devono scrivere direttamente in questo array. Invece, usa
la funzione "wrap_op_checker".

PL_keyword_plugin
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Puntatore a funzione, che punta a una funzione utilizzata per gestire le parole chiave estese. Il
la funzione deve essere dichiarata come

int parola chiave_plugin_funzione(pTHX_
char *keyword_ptr, STRLEN parola chiave_len,
OP **op_ptr)

La funzione viene chiamata dal tokeniser, ogni volta che viene vista una possibile parola chiave.
"keyword_ptr" punta alla parola nel buffer di input del parser e "keyword_len"
dà la sua lunghezza; non è null-terminated. La funzione dovrebbe esaminare
la parola, e possibilmente un altro stato come %^H, per decidere se lo desidera
gestirlo come una parola chiave estesa. In caso contrario, la funzione dovrebbe tornare
"KEYWORD_PLUGIN_DECLINE" e il normale processo di analisi continuerà.

Se la funzione vuole gestire la parola chiave, deve prima analizzare qualsiasi cosa
seguendo la parola chiave che fa parte della sintassi introdotta dalla parola chiave. Vedere
"Interfaccia Lexer" per i dettagli.

Quando una parola chiave viene gestita, la funzione del plugin deve creare un albero di "OP"
strutture, che rappresentano il codice che è stato analizzato. La radice dell'albero deve essere
memorizzato in *op_ptr. La funzione restituisce quindi una costante che indica la sintassi
ruolo del costrutto che ha analizzato: "KEYWORD_PLUGIN_STMT" se è a
istruzione completa o "KEYWORD_PLUGIN_EXPR" se si tratta di un'espressione. Si noti che a
Il costrutto dell'istruzione non può essere utilizzato all'interno di un'espressione (tranne tramite "do BLOCK" e
simile) e un'espressione non è un'istruzione completa (richiede almeno a
punto e virgola finale).

Quando una parola chiave viene gestita, la funzione del plugin può anche avere un lato (tempo di compilazione).
effetti. Può modificare "%^H", definire funzioni e così via. In genere, se laterale
gli effetti sono lo scopo principale di un gestore, non desidera generare alcuna operazione per
essere inseriti nella normale compilazione. In questo caso è ancora necessario
fornire un op tree, ma è sufficiente generare un singolo op nullo.

È così che la funzione *PL_keyword_plugin deve comportarsi in generale.
Convenzionalmente, tuttavia, non si sostituisce completamente l'handler esistente
funzione. Invece, prendi una copia di "PL_keyword_plugin" prima di assegnarne uno tuo
puntatore di funzione ad esso. La tua funzione di gestione dovrebbe cercare le parole chiave che sono
interessati e gestirli. Dove non è interessato, dovrebbe chiamare il
funzione plugin salvata, trasmettendo gli argomenti ricevuti. così
"PL_keyword_plugin" in realtà punta a una catena di funzioni del gestore, tutte
avere l'opportunità di gestire le parole chiave e solo l'ultima funzione della catena
(integrato nel core Perl) normalmente restituirà "KEYWORD_PLUGIN_DECLINE".

GV funzioni

Un GV è una struttura che corrisponde a un typeglob Perl, cioè *foo. È una struttura
che contiene un puntatore a uno scalare, un array, un hash ecc, corrispondente a $foo, @foo, %foo.

I GV si trovano solitamente come valori negli stash (hash della tabella dei simboli) dove Perl li memorizza
variabili globali.

GvAV Restituisce l'AV dal GV.

AV* GvAV(GV* gv)

GvCV Restituire il CV dal GV.

CV* GvCV(GV* gv)

GvHV Restituisce l'HV dal GV.

AT* GvHV(GV* gv)

GvSV Restituisce l'SV dal GV.

SV* GvSV(GV* gv)

gv_const_sv
Se "gv" è un typeglob la cui voce di subroutine è una costante idonea per
inlining, o "gv" è un riferimento segnaposto che verrebbe promosso a tale a
typeglob, quindi restituisce il valore restituito dal sub. In caso contrario, restituisce NULL.

SV* gv_const_sv(GV* gv)

gv_fetchmeth
Come "gv_fetchmeth_pvn", ma manca di un parametro flags.

GV* gv_fetchmeth(HV* scorta, const char* nome,
STRLEN len, livello I32)

gv_fetchmethod_autoload
Restituisce il glob che contiene la subroutine da chiamare per invocare il metodo su
"scorta". Infatti in presenza di autoloading questo potrebbe essere il glob per
"AUTOLOGO". In questo caso la variabile corrispondente $AUTOLOAD è già impostata.

Il terzo parametro di "gv_fetchmethod_autoload" determina se AUTOLOAD
la ricerca viene eseguita se il metodo specificato non è presente: diverso da zero significa sì, guarda
per AUTOCARICO; zero significa no, non cercare AUTOLOAD. Chiamare "gv_fetchmethod" è
equivalente a chiamare "gv_fetchmethod_autoload" con un "autoload" diverso da zero
parametro.

Queste funzioni concedono il token "SUPER" come prefisso del nome del metodo. Nota che se
se vuoi conservare il glob restituito per molto tempo, devi verificarne la presenza
"AUTOLOAD", poiché in un secondo momento la chiamata potrebbe caricare un sottoprogramma diverso dovuto
a $AUTOLOAD modificandone il valore. Usa il glob creato come effetto collaterale da fare
Questo.

Queste funzioni hanno gli stessi effetti collaterali di "gv_fetchmeth" con "level==0". Il
si applica l'avvertimento contro il passaggio del GV restituito da "gv_fetchmeth" a "call_sv".
ugualmente a queste funzioni.

GV* gv_fetchmethod_autoload(HV* scorta,
const char* nome,
autocaricamento I32)

gv_fetchmeth_autoload
Questa è la vecchia forma di "gv_fetchmeth_pvn_autoload", che non ha parametri flags.

GV* gv_fetchmeth_autoload(HV* scorta,
const char* nome,
STRLEN len, livello I32)

gv_fetchmeth_pv
Esattamente come "gv_fetchmeth_pvn", ma accetta una stringa con terminazione null invece di un
coppia stringa/lunghezza.

GV* gv_fetchmeth_pv(HV* scorta, const char* nome,
livello I32, bandiere U32)

gv_fetchmeth_pvn
Restituisce il glob con il "nome" specificato e una subroutine definita o "NULL". Il
glob vive nella "scorta" data, o negli stash accessibili tramite @ISA e
UNIVERSALE::.

L'argomento "livello" dovrebbe essere 0 o -1. Se "livello==0", come effetto collaterale
crea un glob con il dato "nome" nella data "scorta" che nel caso di
success contiene un alias per la subroutine e imposta le informazioni di memorizzazione nella cache per questo
globo.

Gli unici valori significativi per i "flags" sono GV_SUPER e SVf_UTF8.

GV_SUPER indica che vogliamo cercare il metodo nelle superclassi di
"scorta".

Il GV restituito da "gv_fetchmeth" potrebbe essere una voce della cache del metodo, che non lo è
visibile al codice Perl. Quindi, quando chiami "call_sv", non dovresti usare GV
direttamente; invece, dovresti usare il CV del metodo, che puoi ottenere dal
GV con la macro "GvCV".

GV* gv_fetchmeth_pvn(HV* scorta, const char* nome,
STRLEN lente, livello I32,
bandiere U32)

gv_fetchmeth_pvn_autoload
Uguale a gv_fetchmeth_pvn(), ma cerca anche le subroutine caricate automaticamente. Restituisce un
glob per la subroutine.

Per una subroutine caricata automaticamente senza un GV, creerà un GV anche se "livello < 0".
Per una subroutine caricata automaticamente senza stub, GvCV() del risultato può essere zero.

Attualmente, l'unico valore significativo per "flags" è SVf_UTF8.

GV* gv_fetchmeth_pvn_autoload(HV* scorta,
const char* nome,
STRLEN lente, livello I32,
bandiere U32)

gv_fetchmeth_pv_autoload
Esattamente come "gv_fetchmeth_pvn_autoload", ma accetta una stringa con terminazione null
invece di una coppia stringa/lunghezza.

GV* gv_fetchmeth_pv_autoload(HV* scorta,
const char* nome,
livello I32, bandiere U32)

gv_fetchmeth_sv
Esattamente come "gv_fetchmeth_pvn", ma prende la stringa del nome sotto forma di SV
invece di una coppia stringa/lunghezza.

GV* gv_fetchmeth_sv(HV* scorta, SV* nomiv,
livello I32, bandiere U32)

gv_fetchmeth_sv_autoload
Esattamente come "gv_fetchmeth_pvn_autoload", ma prende la stringa del nome sotto forma di
un SV invece di una coppia stringa/lunghezza.

GV* gv_fetchmeth_sv_autoload(HV* scorta, SV* nomiv,
livello I32, bandiere U32)

gv_init La vecchia forma di gv_init_pvn(). Non funziona con le stringhe UTF8, in quanto ha n
parametro flags. Se è impostato il parametro "multi", lo sarà il flag GV_ADDMULTI
passato a gv_init_pvn().

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

gv_init_pv
Uguale a gv_init_pvn(), ma accetta una stringa con terminazione nulla per il nome invece di
separato char * e parametri di lunghezza.

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

gv_init_pvn
Converte uno scalare in un typeglob. Questo è un typeglob incoercibile; assegnare un
il riferimento ad esso verrà assegnato a uno dei suoi slot, invece di sovrascriverlo come
succede con i typeglob creati da SvSetSV. Conversione di qualsiasi scalare che sia SvOK()
può produrre risultati imprevedibili ed è riservato all'uso interno di perl.

"gv" è lo scalare da convertire.

"stash" è la scorta/pacchetto genitore, se presente.

"name" e "len" danno il nome. Il nome deve essere non qualificato; cioè deve
non includere il nome del pacchetto. Se "gv" è un elemento stash, è del chiamante
responsabilità di garantire che il nome passato a questa funzione corrisponda al nome di
l'elemento. Se non corrisponde, la contabilità interna di perl uscirà
sync.

"flags" può essere impostato su SVf_UTF8 se "name" è una stringa UTF8 o il valore restituito di
SvUTF8(sv). Può anche accettare il flag GV_ADDMULTI, il che significa fingere questo
il GV è già stato visto (cioè, sopprimere gli avvisi "Usato una volta").

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

gv_init_sv
Uguale a gv_init_pvn(), ma prende un SV * per il nome invece di un carattere separato *
e parametri di lunghezza. "flags" è attualmente inutilizzato.

void gv_init_sv(GV* gv, HV* scorta, SV* nomiv,
bandiere U32)

gv_stashpv
Restituisce un puntatore alla scorta per un pacchetto specificato. Usa "strlen" per
determina la lunghezza di "name", quindi chiama "gv_stashpvn()".

HV* gv_stashpv(const char* nome, flag I32)

gv_stashpvn
Restituisce un puntatore alla scorta per un pacchetto specificato. Il parametro "namelen".
indica la lunghezza del "nome", in byte. "flags" viene passato a
"gv_fetchpvn_flags()", quindi se impostato su "GV_ADD" il pacchetto verrà creato se
non esiste già. Se il pacchetto non esiste e "flags" è 0 (o any
altra impostazione che non crea pacchetti), viene restituito NULL.

Le bandiere possono essere una di:

GV_ADD
SVf_UTF8
GV_NOADD_NOINIT
GV_NOINIT
GV_NOEXPAND
GV_ADDMG

I più importanti dei quali sono probabilmente GV_ADD e SVf_UTF8.

Nota, l'uso di "gv_stashsv" invece di "gv_stashpvn" ove possibile è fortemente
consigliato per motivi di prestazioni.

HV* gv_stashpvn(const char* nome, U32 namelen,
bandiere I32)

gv_stashpvs
Come "gv_stashpvn", ma accetta una stringa letterale invece di una coppia stringa/lunghezza.

HV* gv_stashpvs(const char* nome, creazione I32)

gv_stashsv
Restituisce un puntatore alla scorta per un pacchetto specificato. Vedere "gv_stashpvn".

Nota che questa interfaccia è fortemente preferita a "gv_stashpvn" per le prestazioni
motivi.

HV* gv_stashsv(SV* sv, I32 flag)

setdefout
Imposta PL_defoutgv, l'handle di file predefinito per l'output, su typeglob passato.
Poiché PL_defoutgv "possiede" un riferimento sul suo typeglob, il conteggio dei riferimenti di
passato in typeglob viene aumentato di uno e il conteggio dei riferimenti del typeglob
a cui punta PL_defoutgv è diminuito di uno.

void setdefout(GV* gv)

a portata di mano Valori

Nullav Puntatore AV nullo.

(obsoleto - usa invece "(AV *)NULL")

Nullch Puntatore a carattere nullo. (Non è più disponibile quando è definito "PERL_CORE".)

Nullcv Puntatore CV nullo.

(obsoleto - usa invece "(CV *)NULL")

Nullhv Puntatore HV nullo.

(obsoleto: utilizzare invece "(HV *)NULL")

Nullsv Puntatore SV nullo. (Non è più disponibile quando è definito "PERL_CORE".)

Hash Manipolazione funzioni

Una struttura HV rappresenta un hash Perl. Consiste principalmente in una serie di puntatori, ciascuno
di cui punta a un elenco collegato di strutture HE. L'array è indicizzato dall'hash
funzione della chiave, quindi ogni elenco collegato rappresenta tutte le voci hash con lo stesso
valore hash. Ciascun HE contiene un puntatore al valore effettivo, più un puntatore a un HEK
struttura che contiene la chiave e il valore hash.

cop_fetch_label
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Restituisce l'etichetta attaccata a un poliziotto. Il puntatore dei flag può essere impostato su "SVf_UTF8"
o 0.

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

cop_store_label
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Salva un'etichetta in un "cop_hints_hash". È necessario impostare i flag su "SVf_UTF8" per a
etichetta utf-8.

void cop_store_label(COP *const poliziotto,
const char *etichetta, STRLEN len,
bandiere U32)

get_hv Restituisce l'HV dell'hash Perl specificato. I "flags" vengono passati a "gv_fetchpv".
Se "GV_ADD" è impostato e la variabile Perl non esiste, verrà creata.
Se "flags" è zero e la variabile non esiste, viene restituito NULL.

NOTA: la forma perl_ di questa funzione è deprecata.

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

HEf_SVKEY
Questo flag, utilizzato nello slot di lunghezza delle voci hash e delle strutture magiche, specifica
la struttura contiene un puntatore "SV*" dove è previsto un puntatore "char*".
(Solo a scopo informativo, da non utilizzare).

HeHASH Restituisce l'hash calcolato memorizzato nella voce hash.

U32 HeHASH(HE* lui)

HeKEY Restituisce il puntatore effettivo memorizzato nello slot della chiave della voce hash. Il puntatore
può essere "char*" o "SV*", a seconda del valore di "HeKLEN()". Può essere
assegnato a. Di solito sono preferibili le macro "HePV()" o "HeSVKEY()".
trovare il valore di una chiave.

void* HeKEY(HE* lui)

HeKLEN Se questo è negativo e ammonta a "HEf_SVKEY", indica che la voce contiene un
Tasto "SV*". In caso contrario, mantiene la lunghezza effettiva della chiave. Può essere assegnato a.
La macro "HePV()" è generalmente preferibile per trovare le lunghezze delle chiavi.

STRLEN HeKLEN(HE* lui)

HePV Restituisce lo slot della chiave della voce hash come valore "char*", facendo tutto il necessario
dereferenziazione di eventuali chiavi "SV*". La lunghezza della corda è posta in "len"
(questa è una macro, quindi fallo non è un usa &len). Se non ti interessa quale sia la lunghezza
della chiave è che puoi usare la variabile globale "PL_na", sebbene questa sia piuttosto inferiore
efficiente rispetto all'utilizzo di una variabile locale. Ricorda però che le chiavi hash in perl
sono liberi di contenere valori null incorporati, quindi usare "strlen()" o simili non va bene
modo per trovare la lunghezza delle chiavi hash. Questo è molto simile alla macro "SvPV()".
descritto altrove in questo documento. Vedi anche "HeUTF8".

Se stai usando "HePV" per ottenere valori da passare a "newSVpvn()" per creare un nuovo SV,
dovresti considerare l'utilizzo di "newSVhek(HeKEY_hek(he))" poiché è più efficiente.

char* HePV(HE* lui, STRLEN len)

HeSVKEY Restituisce la chiave come "SV*" o "NULL" se la voce hash non contiene un "SV*"
chiave.

SV* HeSVKEY(HE* lui)

LuiSVKEY_force
Restituisce la chiave come "SV*". Creerà e restituirà un "SV*" mortale temporaneo se
la voce hash contiene solo una chiave "char*".

SV* HeSVKEY_force(HE* lui)

LuiSVKEY_set
Imposta la chiave su un determinato "SV*", avendo cura di impostare i flag appropriati su
indica la presenza di una chiave "SV*", e restituisce lo stesso "SV*".

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

HeUTF8 Restituisce se il valore "char *" restituito da "HePV" è codificato in UTF-8, facendo
l'eventuale dereferenziazione di chiavi eventualmente "SV*". Il valore restituito sarà 0
o non-0, non necessariamente 1 (o anche un valore con qualsiasi bit basso impostato), quindi do non è un
assegnarlo ciecamente a una variabile "bool", poiché "bool" potrebbe essere un typedef per "char".

U32 HeUTF8(HE* lui)

HeVAL Restituisce lo slot del valore (tipo "SV*") memorizzato nella voce hash. Può essere assegnato a.

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

SV* HeVAL(HE* lui)

HvENAME Restituisce il nome effettivo di una scorta, o NULL se non ce n'è. L'efficace
name rappresenta una posizione nella tabella dei simboli in cui risiede questa scorta. è
aggiornato automaticamente quando i pacchetti vengono alias o eliminati. Una scorta che è no
più nella tabella dei simboli non ha un nome effettivo. Questo nome è preferibile
"HvNAME" per l'uso nelle linearizzazione MRO e nelle cache isa.

char* HvENAME(HV* scorta)

HvENAMELEN
Restituisce la lunghezza del nome effettivo della scorta.

STRLEN HvENAMELEN(HV *scorta)

HvENAMEUTF8
Restituisce true se il nome effettivo è nella codifica UTF8.

carattere non firmato HvENAMEUTF8(HV *stash)

HvNAME Restituisce il nome del pacchetto di una scorta, o NULL se "stash" non è una scorta. Vedere
"SvSTASH", "CvSTASH".

char* HvNAME(HV* scorta)

HvNOMELEN
Restituisce la lunghezza del nome della scorta.

STRLEN HvNAMELEN(HV *scorta)

HvNOMEUTF8
Restituisce true se il nome è nella codifica UTF8.

carattere non firmato HvNAMEUTF8(HV *stash)

hv_assert
Verifica che un hash sia in uno stato internamente coerente.

void hv_assert(HV *hv)

hv_clear
Libera tutti gli elementi di un hash, lasciandolo vuoto. L'equivalente XS di
"% hash = ()". Vedi anche "hv_undef".

Vedere "av_clear" per una nota sull'hash che potrebbe non essere valido al momento della restituzione.

void hv_clear(HV *hv)

hv_clear_placeholders
Cancella eventuali segnaposto da un hash. Se un hash limitato ha una delle sue chiavi
contrassegnata come di sola lettura e la chiave viene successivamente eliminata, la chiave non è effettivamente
cancellato ma viene contrassegnato assegnandogli un valore di &PL_sv_placeholder. Questo lo tagga
quindi verrà ignorato da operazioni future come l'iterazione sull'hash, ma
consentirà comunque all'hash di avere un valore riassegnato alla chiave in un futuro
punto. Questa funzione cancella tutte le chiavi segnaposto dall'hash. Vedere
Hash::Util::lock_keys() per un esempio del suo utilizzo.

void hv_clear_placeholders(HV *hv)

hv_copy_hints_hv
Una versione specializzata di "newHVhv" per la copia di "%^H". Oh deve essere un puntatore a a
hash (che può avere la magia "%^H", ma dovrebbe essere generalmente non magica) o "NULL"
(interpretato come un hash vuoto). Il contenuto di Oh viene copiato in un nuovo hash, che
ha aggiunto la magia specifica "%^H". Viene restituito un puntatore al nuovo hash.

Alta tensione * hv_copy_hints_hv(alta tensione *ohv)

hv_cancella
Elimina una coppia chiave/valore nell'hash. L'SV del valore viene rimosso dall'hash,
reso mortale e restituito al chiamante. Il valore assoluto di "klen" è il
lunghezza della chiave. Se "klen" è negativo, si presume che la chiave sia inserita
Unicode con codifica UTF-8. Il valore "flags" sarà normalmente zero; se impostato su
G_DISCARD quindi verrà restituito NULL. NULL verrà restituito anche se la chiave lo è
non trovato.

SV* hv_delete(HV *hv, const char *chiave, I32 klen,
bandiere I32)

hv_delete_ent
Elimina una coppia chiave/valore nell'hash. Il valore SV viene rimosso dall'hash, creato
mortale, e restituito al chiamante. Il valore "flags" sarà normalmente zero; Se
impostato su G_DISCARD, verrà restituito NULL. NULL verrà restituito anche se il
la chiave non è stata trovata. "hash" può essere un valore hash precalcolato valido o 0 da richiedere
da calcolare.

SV* hv_delete_ent(HV *hv, SV *keysv, flag I32,
hash U32)

hv_esiste
Restituisce un valore booleano che indica se la chiave hash specificata esiste. L'assoluto
il valore di "klen" è la lunghezza della chiave. Se "klen" è negativo, la chiave lo è
si presume che sia in Unicode con codifica UTF-8.

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

hv_esiste_ent
Restituisce un valore booleano che indica se la chiave hash specificata esiste. "hash" può essere
un valore hash precalcolato valido o 0 per richiederne il calcolo.

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

hv_fetch
Restituisce l'SV che corrisponde alla chiave specificata nell'hash. L'assoluto
il valore di "klen" è la lunghezza della chiave. Se "klen" è negativo, la chiave lo è
si presume che sia in Unicode con codifica UTF-8. Se "lval" è impostato, il recupero sarà
parte di un negozio. Ciò significa che se non è presente alcun valore nell'hash associato a
la chiave data, quindi ne viene creata una e viene restituito un puntatore ad essa. Il "SV*".
punti a cui possono essere assegnati. Ma controlla sempre che il valore restituito non sia null
prima di dereferenziarlo a un "SV*".

Per ulteriori informazioni, vedere "Capire la magia degli hash e degli array legati" in perlguts
informazioni su come utilizzare questa funzione su hash legati.

SV** hv_fetch(HV *hv, const char *chiave, I32 klen,
I32 valore)

hv_fetch
Come "hv_fetch", ma accetta una stringa letterale invece di una coppia stringa/lunghezza.

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

hv_fetch_ent
Restituisce la voce hash che corrisponde alla chiave specificata nell'hash. "hash"
deve essere un numero hash precalcolato valido per la "chiave" specificata o 0 se si desidera il
funzione per calcolarlo. SE "lval" è impostato, il recupero farà parte di un negozio.
Assicurati che il valore restituito non sia null prima di accedervi. Il valore restituito quando
"hv" è un hash legato è un puntatore a una posizione statica, quindi assicurati di fare una copia
della struttura se è necessario riporlo da qualche parte.

Per ulteriori informazioni, vedere "Capire la magia degli hash e degli array legati" in perlguts
informazioni su come utilizzare questa funzione su hash legati.

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

hv_fill Restituisce il numero di hash bucket in uso. Questa funzione è
avvolto dalla macro "HvFILL".

In precedenza questo valore veniva sempre memorizzato nella struttura HV, che creava un
sovraccarico su ogni hash (e praticamente su ogni oggetto) per qualcosa che era
utilizzato raramente. Ora lo calcoliamo su richiesta la prima volta che è necessario, e
memorizzalo nella cache se quel calcolo sarà costoso da ripetere. Il valore memorizzato nella cache è
aggiornato da inserimenti ed eliminazioni, ma (attualmente) scartato se l'hash lo è
Diviso.

STRLEN hv_fill(HV *const hv)

hv_iterinit
Prepara un punto di partenza per attraversare una tabella hash. Restituisce il numero di chiavi in
l'hash (cioè lo stesso di "HvUSEDKEYS(hv)"). Il valore restituito è attualmente solo
significativo per hash senza tie magic.

NOTA: prima della versione 5.004_65, "hv_iterinit" restituiva il numero di hash
secchi che sono in uso. Se hai ancora bisogno di quel valore esoterico, puoi farlo
ottenerlo tramite la macro "HvFILL(hv)".

I32 hv_iterinit(HV *hv)

hv_iterkey
Restituisce la chiave dalla posizione corrente dell'iteratore hash. Vedere
"hv_iterinit".

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

hv_iterkeysv
Restituisce la chiave come "SV*" dalla posizione corrente dell'iteratore hash. Il
il valore restituito sarà sempre una copia mortale della chiave. Vedi anche "hv_iterinit".

SV* hv_iterkeysv (voce HE*)

hv_iternext
Restituisce le voci da un iteratore hash. Vedere "hv_iterinit".

Puoi chiamare "hv_delete" o "hv_delete_ent" sulla voce hash che l'iteratore
attualmente punta, senza perdere il tuo posto o invalidare il tuo iteratore.
Nota che in questo caso la voce corrente viene eliminata dall'hash con il tuo
iteratore che contiene l'ultimo riferimento ad esso. Il tuo iteratore è contrassegnato per liberare il
voce alla prossima chiamata a "hv_iternext", quindi non devi scartare il tuo iteratore
immediatamente altrimenti la voce perderà - chiama "hv_iternext" per attivare la risorsa
deallocazione.

HE* hv_iternext(HV *hv)

hv_iternextsv
Esegue un "hv_iternext", "hv_iterkey" e "hv_iterval" in un'unica operazione.

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

hv_iternext_flags
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Restituisce le voci da un iteratore hash. Vedere "hv_iterinit" e "hv_iterenext". Il
Il valore di "flags" sarà normalmente zero; se HV_ITERNEXT_WANTPLACEHOLDERS è impostato il
le chiavi segnaposto (per hash limitati) verranno restituite in aggiunta al normale
chiavi. Per impostazione predefinita, i segnaposto vengono automaticamente ignorati. Attualmente a
placeholder è implementato con un valore che è &PL_sv_placeholder. Si noti che il
l'implementazione di segnaposto e hash limitati può cambiare e il
l'attuazione attualmente non è sufficientemente astratta per rendere ordinata qualsiasi modifica.

HE* hv_iternext_flags(HV *hv, flag I32)

hv_iterval
Restituisce il valore dalla posizione corrente dell'iteratore hash. Vedere
"hv_iterkey".

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

hv_magic
Aggiunge magia a un hash. Vedi "sv_magic".

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

hv_scalare
Valuta l'hash nel contesto scalare e restituisce il risultato. Gestisce la magia quando
l'hash è legato.

SV* hv_scalare(HV *hv)

hv_store
Memorizza un SV in un hash. La chiave hash è specificata come "chiave" e il valore assoluto
di "klen" è la lunghezza della chiave. Se "klen" è negativo, si presume che la chiave lo sia
essere in Unicode con codifica UTF-8. Il parametro "hash" è il valore hash precalcolato;
se è zero allora Perl lo calcolerà.

Il valore restituito sarà NULL se l'operazione non è riuscita o se il valore non è necessario
da memorizzare effettivamente all'interno dell'hash (come nel caso degli hash legati). Altrimenti
può essere dereferenziato per ottenere l'originale "SV*". Si noti che il chiamante lo è
responsabile di incrementare opportunamente il conteggio di riferimento di "val" prima del
call e decrementandolo se la funzione ha restituito NULL. Effettivamente un successo
hv_store assume la proprietà di un riferimento a "val". Questo è di solito quello che tu
volere; un SV appena creato ha un conteggio dei riferimenti di uno, quindi se tutto il tuo codice lo fa
creare SV quindi archiviarli in un hash, hv_store possiederà l'unico riferimento a
nuovo SV e il tuo codice non ha bisogno di fare nient'altro per riordinare. hv_store è
non implementato come chiamata a hv_store_ent e non crea un SV temporaneo per
la chiave, quindi se i dati della tua chiave non sono già in formato SV, usa hv_store in
preferenza per hv_store_ent.

Per ulteriori informazioni, vedere "Capire la magia degli hash e degli array legati" in perlguts
informazioni su come utilizzare questa funzione su hash legati.

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

hv_stores
Come "hv_store", ma accetta una stringa letterale invece di una coppia stringa/lunghezza e
omette il parametro hash.

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

hv_store_ent
Memorizza "val" in un hash. La chiave hash è specificata come "chiave". Il parametro "hash".
è il valore hash precalcolato; se è zero allora Perl lo calcolerà. Il
il valore restituito è la nuova voce hash così creata. Sarà NULL se l'operazione
fallito o se il valore non doveva essere effettivamente memorizzato all'interno dell'hash (come in
il caso degli hash legati). In caso contrario, il contenuto del valore restituito può essere
si accede usando il "Lui?" macro qui descritte. Si noti che il chiamante lo è
responsabile di incrementare opportunamente il conteggio di riferimento di "val" prima del
call e decrementandolo se la funzione ha restituito NULL. Effettivamente un successo
hv_store_ent assume la proprietà di un riferimento a "val". Questo è di solito quello che tu
volere; un SV appena creato ha un conteggio dei riferimenti di uno, quindi se tutto il tuo codice lo fa
creare SV quindi archiviarli in un hash, hv_store possiederà l'unico riferimento a
nuovo SV e il tuo codice non ha bisogno di fare nient'altro per riordinare. Notare che
hv_store_ent legge solo la "chiave"; a differenza di "val" non ne prende possesso,
quindi mantenere il conteggio dei riferimenti corretto su "chiave" è interamente a carico del chiamante
responsabilità. hv_store non è implementato come una chiamata a hv_store_ent, e lo fa
non creare un SV temporaneo per la chiave, quindi se i dati della tua chiave non sono già in SV
modulo quindi usa hv_store al posto di hv_store_ent.

Per ulteriori informazioni, vedere "Capire la magia degli hash e degli array legati" in perlguts
informazioni su come utilizzare questa funzione su hash legati.

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

hv_undef
Non definisce l'hash. L'equivalente XS di "undef(%hash)".

Oltre a liberare tutti gli elementi dell'hash (come hv_clear()), anche questo libera
tutti i dati ausiliari e l'archiviazione associati all'hash.

Vedere "av_clear" per una nota sull'hash che potrebbe non essere valido al momento della restituzione.

vuoto hv_undef(HV *hv)

newHV Crea un nuovo HV. Il conteggio dei riferimenti è impostato su 1.

AT* nuova AT()

gancio manipolazione

Queste funzioni forniscono mezzi convenienti e thread-safe per manipolare le variabili hook.

wrap_op_checker
Inserisce una funzione C nella catena di funzioni di controllo per un tipo di operazione specificato. Questo
è il modo preferito per manipolare l'array "PL_check". codice operativo specifica quale
tipo di operazione deve essere influenzato. nuovo_checker è un puntatore alla funzione C che è
da aggiungere alla catena di controllo di tale codice operativo, e vecchio_checker_p punta al deposito
posizione in cui verrà memorizzato un puntatore alla funzione successiva nella catena. Il
valore di nuovo_puntatore viene scritto nell'array "PL_check", mentre il valore
precedentemente memorizzato lì viene scritto *vecchio_checker_p.

La funzione dovrebbe essere definita in questo modo:

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

Deve essere chiamato in questo modo:

new_checker(aTHX_op)

vecchio_checker_p dovrebbe essere definito così:

statico Perl_check_t old_checker_p;

"PL_check" è globale per un intero processo e un modulo che desidera agganciare op
il controllo può trovarsi invocato più di una volta per processo, in genere in
fili diversi. Per gestire questa situazione, questa funzione è idempotente. Il
località *vecchio_checker_p deve inizialmente (una volta per processo) contenere un puntatore nullo.
Variabile AC di durata statica (dichiarata nell'ambito del file, in genere contrassegnata anche
"statico" per dargli un collegamento interno) verrà inizializzato in modo implicito
in modo appropriato, se non dispone di un inizializzatore esplicito. Questa funzione lo farà
modifica effettivamente la catena di controllo solo se trova *vecchio_checker_p essere nullo. Questo
la funzione è anche thread-safe su piccola scala. Utilizza il blocco appropriato per
evitare le condizioni di gara nell'accesso a "PL_check".

Quando questa funzione viene chiamata, la funzione a cui fa riferimento nuovo_checker deve essere pronto
essere chiamato, salvo *vecchio_checker_p essere vuoto. In una situazione di threading,
nuovo_checker può essere chiamato immediatamente, anche prima che questa funzione venga restituita.
*vecchio_checker_p sarà sempre opportunamente impostato prima nuovo_checker è chiamato. Se
nuovo_checker decide di non fare nulla di speciale con un'operazione che gli viene data (che
è il caso usuale per la maggior parte degli usi dell'aggancio op check), deve concatenare il check
funzione a cui fa riferimento *vecchio_checker_p.

Se si desidera influenzare la compilazione delle chiamate a una specifica subroutine, utilizzare
"cv_set_call_checker" piuttosto che agganciare il controllo di tutte le operazioni "entersub".

void wrap_op_checker(Optype codice operativo,
Perl_check_t nuovo_checker,
Perl_check_t *vecchio_checker_p)

lexer interfaccia

Questo è il livello inferiore del parser Perl, che gestisce personaggi e token.

lex_bufutf8
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Indica se gli ottetti nel buffer lexer ("PL_parser->linestr") devono essere
interpretato come la codifica UTF-8 dei caratteri Unicode. In caso contrario, dovrebbero esserlo
interpretato come caratteri Latin-1. Questo è analogo al flag "SvUTF8" per
scalari.

In modalità UTF-8, non è garantito che il buffer lexer contenga effettivamente valido
UTF-8. Il codice lexing deve essere robusto di fronte a una codifica non valida.

L'attuale flag "SvUTF8" dello scalare "PL_parser->linestr" è significativo, ma
non l'intera storia per quanto riguarda la codifica dei caratteri di input. Normalmente, quando un file
viene letto, lo scalare contiene ottetti e il suo flag "SvUTF8" è disattivato, ma il
gli ottetti dovrebbero essere interpretati come UTF-8 se il pragma "use utf8" è attivo.
Durante una valutazione di stringa, tuttavia, lo scalare potrebbe avere il flag "SvUTF8" attivo e in
in questo caso i suoi ottetti dovrebbero essere interpretati come UTF-8 a meno che il pragma "usa i byte".
è in vigore. Questa logica potrebbe cambiare in futuro; utilizzare questa funzione invece di
implementare la logica da soli.

bool lex_bufutf8()

lex_scartare_a
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Elimina la prima parte del buffer "PL_parser->linestr", fino a PTR.
il contenuto rimanente del buffer verrà spostato e tutti i puntatori nel buffer
aggiornato in modo appropriato. PTR non deve essere più tardi nel buffer rispetto alla posizione di
"PL_parser->bufptr": non è consentito scartare il testo che deve essere ancora letto.

Normalmente non è necessariamente farlo direttamente, perché è sufficiente utilizzare il
comportamento di eliminazione implicito di "lex_next_chunk" e cose basate su di esso.
Tuttavia, se un token si estende su più righe e il codice lexing è stato mantenuto
più righe di testo nel buffer a tale scopo, quindi dopo il completamento di
il token sarebbe saggio scartare esplicitamente le righe precedenti ora non necessarie,
per evitare che futuri token multilinea aumentino il buffer senza limiti.

void lex_discard_to(char *ptr)

lex_grow_linestr
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Rialloca il buffer lexer ("PL_parser->linestr") per ospitare almeno len
ottetti (inclusa la terminazione "NUL"). Restituisce un puntatore al riallocato
respingente. Ciò è necessario prima di apportare qualsiasi modifica diretta al buffer
che ne aumenterebbe la lunghezza. "lex_stuff_pvn" fornisce un modo più conveniente per
inserire il testo nel buffer.

Non utilizzare "SvGROW" o "sv_grow" direttamente su "PL_parser->linestr"; questa funzione
aggiorna tutte le variabili del lexer che puntano direttamente nel buffer.

char * lex_grow_linestr(STRLEN len)

lex_next_chunk
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Legge il successivo blocco di testo da leggere, aggiungendolo a "PL_parser->linestr".
Questo dovrebbe essere chiamato quando il codice lexing ha guardato alla fine del blocco corrente
e vuole saperne di più. È normale, ma non necessario, avere la lexing
consumato l'intero pezzo corrente in questo momento.

Se "PL_parser->bufptr" punta alla fine del blocco corrente (cioè, il
il pezzo corrente è stato interamente consumato), normalmente lo sarà il pezzo corrente
scartato nello stesso momento in cui viene letto il nuovo blocco. Se bandiere inclusi
"LEX_KEEP_PREVIOUS", il blocco corrente non verrà eliminato. Se la corrente
il pezzo non è stato completamente consumato, quindi non verrà scartato a prescindere
la bandiera.

Restituisce true se è stato aggiunto del nuovo testo al buffer o false se è stato aggiunto al buffer
raggiunto la fine del testo di input.

bool lex_next_chunk (bandiere U32)

lex_peek_unichar
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Guarda avanti un carattere (Unicode) nel testo attualmente in lex. ritorna
il punto di codice (valore intero senza segno) del carattere successivo o -1 se lexing ha
raggiunto la fine del testo di input. Per consumare il personaggio sbirciato, usa
"lex_read_unichar".

Se il carattere successivo si trova (o si estende) nel blocco successivo di testo di input, il
verrà letto il blocco successivo. Normalmente il blocco corrente verrà scartato al
stesso tempo, ma se bandiere include "LEX_KEEP_PREVIOUS", quindi il blocco corrente lo farà
non essere scartato.

Se l'input viene interpretato come UTF-8 e un errore di codifica UTF-8 lo è
incontrata, viene generata un'eccezione.

I32 lex_peek_unichar (bandiere U32)

lex_read_space
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Legge gli spazi opzionali, in stile Perl, nel testo attualmente in lex. Il
gli spazi possono includere normali caratteri di spazi bianchi e commenti in stile Perl.
Le direttive "#line" vengono elaborate se incontrate. "PL_parser->bufptr" viene spostato
oltre gli spazi, in modo che punti a un carattere non di spazio (o alla fine del
testo di input).

Se gli spazi si estendono nel blocco successivo di testo di input, verrà letto il blocco successivo
in. Normalmente il blocco corrente verrà scartato allo stesso tempo, ma se bandiere
include "LEX_KEEP_PREVIOUS", il blocco corrente non verrà eliminato.

void lex_read_space (bandiere U32)

lex_read_to
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Consuma testo nel buffer lexer, da "PL_parser->bufptr" fino a PTR. Questo
avanza "PL_parser->bufptr" in modo che corrisponda PTR, effettuando la corretta contabilità
ogni volta che viene passato un carattere di nuova riga. Questo è il modo normale di consumare lexed
testo.

L'interpretazione degli ottetti del buffer può essere estratta usando leggermente
funzioni di livello superiore "lex_peek_unichar" e "lex_read_unichar".

void lex_read_to(char *ptr)

lex_read_unichar
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Legge il carattere successivo (Unicode) nel testo attualmente sottoposto a lex. Restituisce il
codepoint (valore intero senza segno) del carattere letto e si sposta
"PL_parser->bufptr" dopo il carattere, o restituisce -1 se il lexing ha raggiunto il
fine del testo di input. Per esaminare in modo non distruttivo il carattere successivo, utilizzare
"lex_peek_unichar" invece.

Se il carattere successivo si trova (o si estende) nel blocco successivo di testo di input, il
verrà letto il blocco successivo. Normalmente il blocco corrente verrà scartato al
stesso tempo, ma se bandiere include "LEX_KEEP_PREVIOUS", quindi il blocco corrente lo farà
non essere scartato.

Se l'input viene interpretato come UTF-8 e un errore di codifica UTF-8 lo è
incontrata, viene generata un'eccezione.

I32 lex_read_unichar (flag U32)

lex_start
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Crea e inizializza un nuovo oggetto di stato lexer/parser, fornendo un contesto in
che leggere e analizzare da una nuova fonte di codice Perl. Un puntatore al nuovo stato
l'oggetto viene inserito in "PL_parser". Viene fatta una voce nello stack di salvataggio in modo che su
lo svolgimento del nuovo oggetto di stato verrà distrutto e il precedente valore di
"PL_parser" verrà ripristinato. Non è necessario fare altro per ripulire l'analisi
socio-culturale.

Il codice da analizzare viene da linea e a RSFP. linea, se non nullo, fornisce a
stringa (in formato SV) contenente il codice da analizzare. Viene eseguita una copia della stringa,
quindi successiva modifica di linea non influisce sull'analisi. RSFP, se non nullo,
fornisce un flusso di input da cui verrà letto il codice per essere analizzato. Se lo sono entrambi
non null, il codice in linea viene prima e deve consistere in righe complete di
ingresso, e RSFP fornisce il resto della fonte.

Le bandiere parametro è riservato per un uso futuro. Attualmente è usato solo da perl
internamente, quindi le estensioni dovrebbero sempre passare lo zero.

void lex_start(SV *line, PerlIO *rsfp, flag U32)

lex_stuff_pv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Inserisci i caratteri nel buffer lexer ("PL_parser->linestr"), subito dopo
il punto di lexing corrente ("PL_parser->bufptr"), riallocando il buffer se
necessario. Ciò significa che il codice lexing eseguito in seguito vedrà i caratteri come
se fossero apparsi nell'input. Non è consigliabile farlo come parte di
normale analisi e la maggior parte degli usi di questa funzione corre il rischio dell'inserimento
personaggi interpretati in modo non intenzionale.

La stringa da inserire è rappresentata da ottetti che iniziano a pv e continuando
al primo null. Questi ottetti sono interpretati come UTF-8 o Latin-1,
a seconda che sia impostato il flag "LEX_STUFF_UTF8". bandiere. I personaggi
vengono ricodificati per il buffer lexer, a seconda di come si trova attualmente il buffer
interpretato ("lex_bufutf8"). Se non è conveniente terminare con null una stringa in
essere inserito, la funzione "lex_stuff_pvn" è più appropriata.

void lex_stuff_pv(const char *pv, flag U32)

lex_stuff_pvn
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Inserisci i caratteri nel buffer lexer ("PL_parser->linestr"), subito dopo
il punto di lexing corrente ("PL_parser->bufptr"), riallocando il buffer se
necessario. Ciò significa che il codice lexing eseguito in seguito vedrà i caratteri come
se fossero apparsi nell'input. Non è consigliabile farlo come parte di
normale analisi e la maggior parte degli usi di questa funzione corre il rischio dell'inserimento
personaggi interpretati in modo non intenzionale.

La stringa da inserire è rappresentata da len ottetti a partire da pv. Queste
gli ottetti sono interpretati come UTF-8 o Latin-1, a seconda che il
Il flag "LEX_STUFF_UTF8" è impostato bandiere. I caratteri vengono ricodificati per il lexer
buffer, in base a come viene attualmente interpretato il buffer
("lex_bufutf8"). Se una stringa da inserire è disponibile come scalare Perl, il file
La funzione "lex_stuff_sv" è più conveniente.

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

lex_stuff_pvs
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Come "lex_stuff_pvn", ma accetta una stringa letterale invece di una coppia stringa/lunghezza.

void lex_stuff_pvs(const char *pv, flag U32)

lex_stuff_sv
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Inserisci i caratteri nel buffer lexer ("PL_parser->linestr"), subito dopo
il punto di lexing corrente ("PL_parser->bufptr"), riallocando il buffer se
necessario. Ciò significa che il codice lexing eseguito in seguito vedrà i caratteri come
se fossero apparsi nell'input. Non è consigliabile farlo come parte di
normale analisi e la maggior parte degli usi di questa funzione corre il rischio dell'inserimento
personaggi interpretati in modo non intenzionale.

La stringa da inserire è il valore della stringa di sv. I caratteri vengono ricodificati
per il lexer buffer, a seconda di come viene attualmente interpretato il buffer
("lex_bufutf8"). Se una stringa da inserire non è già uno scalare Perl, il
La funzione "lex_stuff_pvn" evita la necessità di costruire uno scalare.

void lex_stuff_sv(SV *sv, flag U32)

lex_unstuff
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Elimina il testo che sta per essere lexato, da "PL_parser->bufptr" fino a PTR. Testo
i seguenti PTR verrà spostato e il buffer accorciato. Questo nasconde gli scartati
testo da qualsiasi codice lexing eseguito successivamente, come se il testo non fosse mai apparso.

Questo non è il modo normale di consumare testo lexed. Per questo, usa "lex_read_to".

void lex_unstuff(char *ptr)

parse_aritheexpr
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza un'espressione aritmetica Perl. Questo può contenere operatori di precedenza verso il basso
agli operatori di bit shift. L'espressione deve essere seguita (e quindi terminata)
da un operatore di confronto o di precedenza inferiore o da qualcosa che lo farebbe
normalmente termina un'espressione come punto e virgola. Se bandiere inclusi
"PARSE_OPTIONAL" quindi l'espressione è facoltativa, altrimenti è obbligatoria. Esso
spetta al chiamante assicurarsi che lo stato del parser dinamico ("PL_parser" et al).
impostato correttamente per riflettere l'origine del codice da analizzare e il lessico
contesto per l'espressione.

Viene restituito l'albero operativo che rappresenta l'espressione. Se è un'espressione facoltativa
assente, viene restituito un puntatore nullo, altrimenti il ​​puntatore sarà non null.

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi lo è un albero operativo valido
restituito comunque. L'errore si riflette nello stato del parser, normalmente risultante
in un'unica eccezione al livello superiore dell'analisi che copre tutta la compilazione
errori che si sono verificati. Alcuni errori di compilazione, tuttavia, genereranno un'eccezione
immediatamente.

OP * parse_arithexpr (flag U32)

parse_barestmt
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza una singola istruzione Perl disadorna. Questo potrebbe essere un normale imperativo
istruzione o una dichiarazione che ha effetto in fase di compilazione. Non ne include nessuno
etichetta o altro apposizione. Spetta al chiamante garantire che la dinamica
lo stato del parser ("PL_parser" et al) è impostato correttamente per riflettere l'origine del file
codice da analizzare e il contesto lessicale dell'istruzione.

Viene restituito l'albero operativo che rappresenta l'istruzione. Questo potrebbe essere un puntatore nullo se
l'istruzione è nulla, ad esempio se fosse effettivamente una definizione di subroutine
(che ha effetti collaterali in fase di compilazione). Se non null, sarà direttamente ops
in attuazione della dichiarazione, idonea a passare a "newSTATEOP". Non lo farà
normalmente includono un "nextstate" o op equivalente (ad eccezione di quelli incorporati in a
ambito contenuto interamente nella dichiarazione).

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi un albero operativo valido (most
probabile null) viene comunque restituito. L'errore si riflette nello stato del parser,
normalmente risultando in una singola eccezione al livello superiore di analisi che copre
tutti gli errori di compilazione verificatisi. Alcuni errori di compilazione, tuttavia, lo faranno
lanciare immediatamente un'eccezione.

Le bandiere parametro è riservato per usi futuri e deve essere sempre zero.

OP * parse_barestmt (bandiere U32)

blocco_analisi
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza un singolo blocco di codice Perl completo. Questo consiste in una parentesi graffa di apertura, a
sequenza di istruzioni e una parentesi graffa di chiusura. Il blocco costituisce un lessicale
scope, quindi le "mie" variabili e vari effetti in fase di compilazione possono essere contenuti all'interno
esso. Spetta al chiamante assicurarsi che lo stato del parser dinamico ("PL_parser"
et al) è impostato correttamente per riflettere l'origine del codice da analizzare e il
contesto lessicale dell'enunciato.

Viene restituito l'albero operativo che rappresenta il blocco di codice. Questa è sempre una vera operazione,
mai un puntatore nullo. Normalmente sarà un elenco "lineseq", incluso "nextstate"
o operazioni equivalenti. Non sono incluse operazioni per costruire alcun tipo di ambito di runtime
virtù di essere un blocco.

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi un albero operativo valido (most
probabile null) viene comunque restituito. L'errore si riflette nello stato del parser,
normalmente risultando in una singola eccezione al livello superiore di analisi che copre
tutti gli errori di compilazione verificatisi. Alcuni errori di compilazione, tuttavia, lo faranno
lanciare immediatamente un'eccezione.

Le bandiere parametro è riservato per usi futuri e deve essere sempre zero.

OP * parse_block (flag U32)

parse_fullexpr
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza una singola espressione Perl completa. Ciò consente la grammatica dell'espressione completa,
compresi gli operatori con la precedenza più bassa come "o". L'espressione deve essere
seguito (e quindi terminato) da un token che normalmente sarebbe un'espressione
terminato da: fine del file, parentesi chiusa con punteggiatura, punto e virgola o uno dei
le parole chiave che segnalano un modificatore di istruzione di espressione suffisso. Se bandiere
include "PARSE_OPTIONAL", quindi l'espressione è facoltativa, altrimenti lo è
obbligatorio. Spetta al chiamante garantire che lo stato del parser dinamico
("PL_parser" et al) è impostato correttamente per riflettere l'origine del codice
analizzato e il contesto lessicale per l'espressione.

Viene restituito l'albero operativo che rappresenta l'espressione. Se è un'espressione facoltativa
assente, viene restituito un puntatore nullo, altrimenti il ​​puntatore sarà non null.

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi lo è un albero operativo valido
restituito comunque. L'errore si riflette nello stato del parser, normalmente risultante
in un'unica eccezione al livello superiore dell'analisi che copre tutta la compilazione
errori che si sono verificati. Alcuni errori di compilazione, tuttavia, genereranno un'eccezione
immediatamente.

OP * parse_fullexpr (flag U32)

parse_fullstmt
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza una singola istruzione Perl completa. Questa potrebbe essere una normale affermazione dell'imperativo
o una dichiarazione che ha effetto in fase di compilazione e può includere etichette facoltative.
Spetta al chiamante assicurarsi che lo stato del parser dinamico ("PL_parser" et al)
è impostato correttamente per riflettere l'origine del codice da analizzare e il lessico
contesto per la dichiarazione.

Viene restituito l'albero operativo che rappresenta l'istruzione. Questo potrebbe essere un puntatore nullo se
l'istruzione è nulla, ad esempio se fosse effettivamente una definizione di subroutine
(che ha effetti collaterali in fase di compilazione). Se non nullo, sarà il risultato di a
chiamata "newSTATEOP", che normalmente include un "nextstate" o equivalente op.

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi un albero operativo valido (most
probabile null) viene comunque restituito. L'errore si riflette nello stato del parser,
normalmente risultando in una singola eccezione al livello superiore di analisi che copre
tutti gli errori di compilazione verificatisi. Alcuni errori di compilazione, tuttavia, lo faranno
lanciare immediatamente un'eccezione.

Le bandiere parametro è riservato per usi futuri e deve essere sempre zero.

OP * parse_fullstmt (bandiere U32)

analizza_etichetta
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza una singola etichetta, possibilmente facoltativa, del tipo che può prefissare un Perl
dichiarazione. Spetta al chiamante garantire che lo stato del parser dinamico
("PL_parser" et al) è impostato correttamente per riflettere l'origine del codice
analizzato. Se bandiere include "PARSE_OPTIONAL", l'etichetta è facoltativa, altrimenti
è obbligatorio.

Il nome dell'etichetta viene restituito sotto forma di un nuovo scalare. Se opzionale
label è assente, viene restituito un puntatore null.

Se si verifica un errore durante l'analisi, che può verificarsi solo se l'etichetta è obbligatoria, a
viene comunque restituita un'etichetta valida. L'errore si riflette nello stato del parser,
normalmente risultando in una singola eccezione al livello superiore di analisi che copre
tutti gli errori di compilazione verificatisi.

SV * parse_label (flag U32)

parse_listexpr
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza un'espressione elenco Perl. Questo può contenere operatori di precedenza fino a
l'operatore virgola. Anche l'espressione deve essere seguita (e quindi terminata).
da un operatore logico a bassa precedenza come "o" o da qualcosa che lo farebbe
normalmente termina un'espressione come punto e virgola. Se bandiere inclusi
"PARSE_OPTIONAL" quindi l'espressione è facoltativa, altrimenti è obbligatoria. Esso
spetta al chiamante assicurarsi che lo stato del parser dinamico ("PL_parser" et al).
impostato correttamente per riflettere l'origine del codice da analizzare e il lessico
contesto per l'espressione.

Viene restituito l'albero operativo che rappresenta l'espressione. Se è un'espressione facoltativa
assente, viene restituito un puntatore nullo, altrimenti il ​​puntatore sarà non null.

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi lo è un albero operativo valido
restituito comunque. L'errore si riflette nello stato del parser, normalmente risultante
in un'unica eccezione al livello superiore dell'analisi che copre tutta la compilazione
errori che si sono verificati. Alcuni errori di compilazione, tuttavia, genereranno un'eccezione
immediatamente.

OP * parse_listexpr (flag U32)

parse_stmtseq
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza una sequenza di zero o più istruzioni Perl. Questi possono essere un imperativo normale
istruzioni, incluse etichette facoltative o dichiarazioni con fase di compilazione
effetto, o qualsiasi loro miscela. La sequenza di istruzioni termina quando una parentesi graffa di chiusura
o la fine del file si incontra in un luogo in cui una nuova istruzione potrebbe essere validamente
cominciato. Spetta al chiamante garantire che lo stato del parser dinamico
("PL_parser" et al) è impostato correttamente per riflettere l'origine del codice
analizzato e il contesto lessicale delle affermazioni.

Viene restituito l'albero operativo che rappresenta la sequenza di istruzioni. Questo potrebbe essere un valore nullo
pointer se le istruzioni erano tutte nulle, ad esempio se non c'erano istruzioni
o se c'erano solo definizioni di subroutine (che hanno lato in fase di compilazione
effetti). Se non è nullo, sarà un elenco "lineseq", normalmente incluso
"nextstate" o operazioni equivalenti.

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi lo è un albero operativo valido
restituito comunque. L'errore si riflette nello stato del parser, normalmente risultante
in un'unica eccezione al livello superiore dell'analisi che copre tutta la compilazione
errori che si sono verificati. Alcuni errori di compilazione, tuttavia, genereranno un'eccezione
immediatamente.

Le bandiere parametro è riservato per usi futuri e deve essere sempre zero.

OP * parse_stmtseq (bandiere U32)

parse_termexpr
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Analizza un'espressione di un termine Perl. Questo può contenere operatori di precedenza fino a
gli operatori di assegnazione. L'espressione deve essere seguita (e quindi terminata)
da una virgola o da un operatore con precedenza inferiore o da qualcosa che sarebbe normalmente
terminare un'espressione come punto e virgola. Se bandiere include "PARSE_OPTIONAL"
allora l'espressione è facoltativa, altrimenti è obbligatoria. Spetta al
chiamante per garantire che lo stato del parser dinamico ("PL_parser" et al) sia corretto
impostato per riflettere l'origine del codice da analizzare e il contesto lessicale per il
espressione.

Viene restituito l'albero operativo che rappresenta l'espressione. Se è un'espressione facoltativa
assente, viene restituito un puntatore nullo, altrimenti il ​​puntatore sarà non null.

Se si verifica un errore durante l'analisi o la compilazione, nella maggior parte dei casi lo è un albero operativo valido
restituito comunque. L'errore si riflette nello stato del parser, normalmente risultante
in un'unica eccezione al livello superiore dell'analisi che copre tutta la compilazione
errori che si sono verificati. Alcuni errori di compilazione, tuttavia, genereranno un'eccezione
immediatamente.

OP * parse_termexpr (flag U32)

PL_parser
Puntatore a una struttura che incapsula attualmente lo stato dell'operazione di analisi
in corso. Il puntatore può essere modificato localmente per eseguire un'analisi nidificata senza
interferire con lo stato di un'analisi esterna. Membri individuali di "PL_parser"
avere la propria documentazione.

PL_parser->buffe
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Puntatore diretto alla fine del pezzo di testo attualmente in lex, la fine di
il buffer di lexer. Questo è uguale a "SvPVX(PL_parser->linestr) +
SvCUR(PL_parser->linestr)". Un carattere "NUL" (zero ottetto) si trova sempre in
la fine del buffer e non conta come parte del contenuto del buffer.

PL_parser->buffptr
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Punta alla posizione corrente di lexing all'interno del buffer lexer. Personaggi
intorno a questo punto possono essere liberamente esaminati, entro l'intervallo delimitato da
"SvPVX("PL_parser->linestr")" e "PL_parser->buffend". Gli ottetti del buffer
può essere inteso come UTF-8 o Latin-1, come indicato da
"lex_bufutf8".

Il codice lexing (che sia nel core Perl o meno) sposta questo puntatore oltre il
caratteri che consuma. Si prevede inoltre di eseguire alcune operazioni di contabilità
ogni volta che viene consumato un carattere di nuova riga. Questo movimento può essere più conveniente
eseguita dalla funzione "lex_read_to", che gestisce i newline in modo appropriato.

L'interpretazione degli ottetti del buffer può essere estratta usando leggermente
funzioni di livello superiore "lex_peek_unichar" e "lex_read_unichar".

PL_parser->linestart
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Punta all'inizio della riga corrente all'interno del buffer lexer. Questo è utile
per indicare in quale colonna si è verificato un errore e non molto altro. Questo deve essere
aggiornato da qualsiasi codice lexing che consuma una nuova riga; la funzione "lex_read_to"
gestisce questo dettaglio.

PL_parser->linestr
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Buffer scalare contenente il pezzo attualmente in esame del testo
attualmente lessato. Si tratta sempre di una semplice stringa scalare (per cui "SvPOK" è
VERO). Non è inteso per essere utilizzato come scalare con normali mezzi scalari; invece
fare riferimento al buffer direttamente dalle variabili del puntatore descritte di seguito.

Il lexer mantiene vari puntatori "char*" a cose in "PL_parser->linestr"
respingente. Se "PL_parser->linestr" viene mai riallocato, tutti questi puntatori devono
essere aggiornato. Non tentare di farlo manualmente, ma piuttosto usa "lex_grow_linestr"
se è necessario riallocare il buffer.

Il contenuto del blocco di testo nel buffer è comunemente esattamente una riga completa
di input, fino a includere un terminatore di nuova riga, ma ci sono situazioni in cui
è altrimenti. Gli ottetti del buffer possono essere interpretati come
o UTF-8 o Latin-1. La funzione "lex_bufutf8" ti dice quale. Non usare
il flag "SvUTF8" su questo scalare, che potrebbe non essere d'accordo con esso.

Per l'esame diretto del buffer, punta la variabile "PL_parser->bufend".
la fine del buffer. L'attuale posizione di lexing è indicata da
"PL_parser->buffptr". L'uso diretto di questi puntatori è generalmente preferibile
esame dello scalare attraverso normali mezzi scalari.

Locale funzioni e a macro

DECLARATION_FOR_LC_NUMERIC_MANIPOLATION
Questa macro deve essere utilizzata come un'istruzione. Dichiara una variabile privata (la cui
il nome inizia con un trattino basso) che è necessario per le altre macro in questo
sezione. La mancata inclusione di questo correttamente dovrebbe causare un errore di sintassi. Per
compatibilità con i compilatori C89 C dovrebbe essere inserito in un blocco prima di qualsiasi
istruzioni eseguibili.

invalidare DECLARATION_FOR_LC_NUMERIC_MANIPULATION

RESTORE_LC_NUMERIC
Viene utilizzato insieme a una delle macro
"STORE_LC_NUMERIC_SET_TO_NEEDED" e "STORE_LC_NUMERIC_FORCE_TO_UNDERLYING"

per ripristinare correttamente lo stato "LC_NUMERIC".

È necessario che sia stata effettuata una chiamata a "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" per dichiarare
in fase di compilazione una variabile privata utilizzata da questa macro e le due "STORE".
Questa macro dovrebbe essere chiamata come una singola istruzione, non un'espressione, ma con un
elenco di argomenti vuoto, in questo modo:

{
DECLARATION_FOR_LC_NUMERIC_MANIPOLATION;
...
RIPRISTINA_LC_NUMERIC();
...
}

vuoto RESTORE_LC_NUMERIC()

STORE_LC_NUMERIC_FORCE_TO_UNDERLYING
Viene utilizzato dal codice XS che riconosce la locale "LC_NUMERIC" per forzare la locale
affinché la categoria "LC_NUMERIC" sia quella che perl pensa sia l'attuale locale sottostante.
(L'interprete perl potrebbe essere sbagliato su quale sia effettivamente la localizzazione sottostante
se un codice C o XS ha chiamato la funzione di libreria C setlocale(3) dietro di esso
Indietro; chiamare "sync_locale" prima di chiamare questa macro aggiornerà i record di Perl.)

È necessario che sia stata effettuata una chiamata a "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" per dichiarare
in fase di compilazione una variabile privata utilizzata da questa macro. Questa macro dovrebbe essere
chiamato come una singola istruzione, non un'espressione, ma con un elenco di argomenti vuoto,
come questo:

{
DECLARATION_FOR_LC_NUMERIC_MANIPOLATION;
...
STORE_LC_NUMERIC_FORCE_TO_UNDERLYING();
...
RIPRISTINA_LC_NUMERIC();
...
}

La variabile private viene utilizzata per salvare lo stato della locale corrente, in modo che il file
la chiamata di corrispondenza richiesta a "RESTORE_LC_NUMERIC" può ripristinarla.

annullare STORE_LC_NUMERIC_FORCE_TO_UNDERLYING()

STORE_LC_NUMERIC_SET_TO_NEEDED
Viene utilizzato per eseguire il wrapping del codice XS o C compatibile con le impostazioni locali di "LC_NUMERIC".
Questa categoria locale è generalmente mantenuta impostata su C locale da Perl per le versioni precedenti
compatibilità e perché la maggior parte del codice XS che legge valori in virgola mobile può farcela
solo con il carattere della radice decimale che è un punto.

Questa macro assicura che lo stato "LC_NUMERIC" corrente sia impostato correttamente, per essere consapevole
di locale se la chiamata al codice XS o C dal programma Perl proviene dall'interno di
ambito di un "uso locale"; o per ignorare la locale se la chiamata è invece dall'esterno
tale portata.

Questa macro è l'inizio del wrapping del codice C o XS; il finale dell'avvolgimento è terminato
richiamando la macro "RESTORE_LC_NUMERIC" dopo l'operazione. Altrimenti lo Stato
può essere modificato che influirà negativamente su altri codici XS.

È necessario che sia stata effettuata una chiamata a "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" per dichiarare
in fase di compilazione una variabile privata utilizzata da questa macro. Questa macro dovrebbe essere
chiamato come una singola istruzione, non un'espressione, ma con un elenco di argomenti vuoto,
come questo:

{
DECLARATION_FOR_LC_NUMERIC_MANIPOLATION;
...
STORE_LC_NUMERIC_SET_TO_NEEDED();
...
RIPRISTINA_LC_NUMERIC();
...
}

vuoto STORE_LC_NUMERIC_SET_TO_NEEDED()

sync_locale
La modifica della localizzazione del programma dovrebbe essere evitata dal codice XS. Tuttavia, certo
le librerie non Perl chiamate da XS, come "Gtk", lo fanno. Quando ciò accade, Perl
deve essere detto che il locale è cambiato. Utilizzare questa funzione per farlo, prima
tornando al Perl.

void sync_locale()

Magico funzioni

mg_clear
Cancella qualcosa di magico che l'SV rappresenta. Vedi "sv_magic".

int mg_clear(SV*sv)

mg_copy Copia la magia da un SV all'altro. Vedi "sv_magic".

int mg_copy(SV *sv, SV *nsv, const char *chiave,
I32 colore)

mg_find Trova il puntatore magico per il tipo che corrisponde all'SV. Vedi "sv_magic".

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

mg_findext
Trova il puntatore magico di "tipo" con il dato "vtbl" per "SV". Vedere
"sv_magicext".

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

mg_free Libera qualsiasi memoria magica utilizzata dall'SV. Vedi "sv_magic".

int mg_free(SV*sv)

mg_free_type
Rimuovi qualsiasi tipo di magia come dalla SV sv. Vedi "sv_magic".

void mg_free_type(SV *sv, int come)

mg_get Esegui la magia prima che un valore venga recuperato dall'SV. Il tipo di SV deve essere >=
SVt_PVMG. Vedi "sv_magic".

int mg_get(SV*sv)

mg_lunghezza
DEPRECATO! Si prevede di rimuovere questa funzione da una futura versione di Perl.
Non usarlo per il nuovo codice; rimuoverlo dal codice esistente.

Riporta la lunghezza dell'SV in byte, chiamando la lunghezza magica se disponibile, ma lo fa
non impostare il flag UTF8 su sv. Tornerà a "prendere" la magia se non c'è
magia di "lunghezza", ma senza indicazione se si chiamasse magia di "ottenimento". Esso
presuppone che sv sia un PVMG o superiore. Uso sv_len() anziché.

U32 mg_lunghezza(SV* sv)

mg_magico
Attiva lo stato magico di un SV. Vedi "sv_magic".

vuoto mg_magico(SV* sv)

mg_set Esegui la magia dopo che un valore è stato assegnato all'SV. Vedi "sv_magic".

int mg_set(SV*sv)

SvGETMAGIC
Richiama "mg_get" su un SV se ha la magia "get". Ad esempio, questo chiamerà
"FETCH" su una variabile legata. Questa macro valuta il suo argomento più di una volta.

vuoto SvGETMAGIC(SV* sv)

SvLOCK Fa in modo che si ottenga un blocco di mutua esclusione su sv se è presente un modulo adatto
stato caricato.

void SvLOCK(SV*sv)

SvSETMAGIC
Richiama "mg_set" su un SV se ha la magia "set". Questo è necessario dopo
modificando uno scalare, nel caso sia una variabile magica come $| o una variabile legata
(si chiama "STORE"). Questa macro valuta il suo argomento più di una volta.

vuoto SvSETMAGIC(SV* sv)

SvSetMagicSV
Come "SvSetSV", ma esegue qualsiasi set magic richiesto in seguito.

void SvSetMagicSV(SV* dsv, SV* ssv)

SvSetMagicSV_nosteal
Come "SvSetSV_nosteal", ma esegue qualsiasi set magic richiesto in seguito.

void SvSetMagicSV_nosteal(SV* dsv, SV* ssv)

SvSetSV Chiama "sv_setsv" se dsv non è uguale a ssv. Può valutare gli argomenti più di
una volta. Non gestisce la magia "set" sull'SV di destinazione.

void SvSetSV(SV* dsv, SV* ssv)

SvSetSV_nosteal
Chiama una versione non distruttiva di "sv_setsv" se dsv non è uguale a ssv. Maggio
valutare gli argomenti più di una volta.

void SvSetSV_nosteal(SV* dsv, SV* ssv)

SvSHARE Fa in modo che sv venga condiviso tra i thread se è stato caricato un modulo adatto.

void SvSHARE(SV* sv)

SvUNLOCK
Rilascia un blocco di mutua esclusione su sv se è stato caricato un modulo adatto.

void SvUNLOCK(SV*sv)

Memorie Management

Copia l'interfaccia del writer XSUB nella funzione C "memcpy". La "src" è la fonte,
"dest" è la destinazione, "nitems" è il numero di elementi e "type" è il
genere. Potrebbe non riuscire sulle copie sovrapposte. Vedi anche "Sposta".

void Copy(void* src, void* dest, int nitems, tipo)

CopyD Come "Copia" ma restituisce dest. Utile per incoraggiare i compilatori a tail-call
ottimizzare.

void * CopyD(void* src, void* dest, int nitems, tipo)

Spostare l'interfaccia del writer XSUB sulla funzione C "memove". La "src" è la fonte,
"dest" è la destinazione, "nitems" è il numero di elementi e "type" è il
genere. Può fare mosse sovrapposte. Vedi anche "Copia".

void Move(void* src, void* dest, int nitems, tipo)

MoveD Come "Move" ma restituisce dest. Utile per incoraggiare i compilatori a tail-call
ottimizzare.

void * MoveD(void* src, void* dest, int nitems, tipo)

Newx L'interfaccia del writer XSUB alla funzione C "maloc".

La memoria ottenuta da questo dovrebbe SOLO essere liberato con "Safefree".

Nel 5.9.3, Newx() e gli amici sostituiscono il più vecchio Nuovo () API e rilascia il primo
parametro, x, un aiuto per il debug che ha permesso ai chiamanti di identificarsi. Questo aiuto
è stato sostituito da una nuova opzione di compilazione, PERL_MEM_LOG (vedi "PERL_MEM_LOG" in
perlhacktips). L'API precedente è ancora lì per l'uso nel supporto dei moduli XS
perl più vecchi.

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

Newxc L'interfaccia del writer XSUB alla funzione C "malloc", con cast. Guarda anche
"Nuovo".

La memoria ottenuta da questo dovrebbe SOLO essere liberato con "Safefree".

void Newxc(void* ptr, int nitems, tipo, cast)

Newxz L'interfaccia del writer XSUB alla funzione C "malloc". La memoria allocata è
azzerato con "memzero". Vedi anche "Newx".

La memoria ottenuta da questo dovrebbe SOLO essere liberato con "Safefree".

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

Veleno Veleno Con(0xEF) per catturare l'accesso alla memoria liberata.

void Veleno(void* dest, int nitems, tipo)

VelenoLibero
Veleno Con(0xEF) per catturare l'accesso alla memoria liberata.

void PoisonFree(void* dest, int nitems, tipo)

VelenoNuovo
Veleno Con(0xAB) per catturare l'accesso alla memoria allocata ma non inizializzata.

void PoisonNew(void* destinazione, int nitems, tipo)

Veleno Con
Riempi la memoria con un modello di byte (un byte ripetuto più e più volte) che
si spera che catturi i tentativi di accedere alla memoria non inizializzata.

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

Rinnova l'interfaccia del writer XSUB con la funzione C "realloc".

La memoria ottenuta da questo dovrebbe SOLO essere liberato con "Safefree".

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

Renewc L'interfaccia del writer XSUB alla funzione C "realloc", con cast.

La memoria ottenuta da questo dovrebbe SOLO essere liberato con "Safefree".

void Renewc(void* ptr, int nitems, tipo, cast)

Senza cassaforte
L'interfaccia del writer XSUB alla funzione C "free".

Questo dovrebbe SOLO essere usato sulla memoria ottenuta usando "Newx" e amici.

void Safefree(void* ptr)

savepv La versione di Perl di "strdup()". Restituisce un puntatore a una stringa appena allocata che
è un duplicato di "pv". La dimensione della stringa è determinata da "strlen()", che
significa che potrebbe non contenere caratteri "NUL" incorporati e deve avere un "NUL" finale.
La memoria allocata per la nuova stringa può essere liberata con "Safefree()"
funzione.

Su alcune piattaforme, ad esempio Windows, tutta la memoria allocata di proprietà di un thread è
deallocato quando quel thread finisce. Quindi, se hai bisogno che ciò non accada, devi farlo
utilizzare le funzioni di memoria condivisa, come "savesharedpv".

char* savepv(const char* pv)

savepvn La versione di Perl di cosa sarebbe "strndup()" se esistesse. Restituisce un puntatore a
stringa appena allocata che è un duplicato dei primi byte "len" di "pv",
più un byte "NUL" finale. La memoria allocata per la nuova stringa può essere liberata
con la funzione "Safefree()".

Su alcune piattaforme, ad esempio Windows, tutta la memoria allocata di proprietà di un thread è
deallocato quando quel thread finisce. Quindi, se hai bisogno che ciò non accada, devi farlo
utilizzare le funzioni di memoria condivisa, come "savesharedpvn".

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

savepvs Come "savepvn", ma accetta una stringa con terminazione letterale "NUL" invece di una
coppia stringa/lunghezza.

char* savepvs(const char* s)

savesharedpv
Una versione di "savepv()" che alloca la stringa duplicata in memoria che è
condiviso tra i thread.

char* savesharedpv(const char* pv)

savesharedpvn
Una versione di "savepvn()" che alloca la stringa duplicata in memoria che è
condiviso tra i thread. (Con la differenza specifica che un puntatore NULL non lo è
accettabile)

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

savesharedpvs
Una versione di "savepvs()" che alloca la stringa duplicata in memoria che è
condiviso tra i thread.

char* savesharedpvs(const char* s)

savesharedvpv
Una versione di "savesharedpv()" che alloca la stringa duplicata in memoria che
è condiviso tra i thread.

char* salvacondivisivpv(SV *sv)

savevpv
Una versione di "savepv()"/"savepvn()" che ottiene la stringa da duplicare dal
passato in SV usando "SvPV()"

Su alcune piattaforme, ad esempio Windows, tutta la memoria allocata di proprietà di un thread è
deallocato quando quel thread finisce. Quindi, se hai bisogno che ciò non accada, devi farlo
utilizzare le funzioni di memoria condivisa, come "savesharedsvpv".

char* salvavpv(SV* sv)

structCopy
Questa è una macro indipendente dall'architettura per copiare una struttura in un'altra.

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

Zero L'interfaccia del writer XSUB alla funzione C "memzero". Il "dest" è il
destinazione, "nitems" è il numero di elementi e "tipo" è il tipo.

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

ZeroD Come "Zero" ma restituisce dest. Utile per incoraggiare i compilatori a tail-call
ottimizzare.

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

Miscellanea funzioni

dump_c_backtrace
Scarica il backtrace C al fp dato.

Restituisce true se è possibile recuperare un backtrace, false in caso contrario.

bool dump_c_backtrace(PerlIO* fp, int max_profondità,
int salta)

fbm_compila
Analizza la stringa per effettuare ricerche veloci su di essa utilizzando fbm_instr() -- il
Algoritmo Boyer-Moore.

void fbm_compile(SV* sv, flag U32)

fbm_instr
Restituisce la posizione dell'SV nella stringa delimitata da "big" e "bigend". Esso
restituisce "NULL" se non è possibile trovare la stringa. Il "sv" non deve essere
fbm_compiled, ma la ricerca non sarà così veloce.

char* fbm_instr(carattere senza segno* grande,
carattere senza segno* bigend, SV* littlestr,
bandiere U32)

foldEQ Restituisce vero se i byte len iniziali delle stringhe s1 e s2 sono lo stesso caso-
insensibile; falso altrimenti. I byte dell'intervallo ASCII maiuscolo e minuscolo corrispondono
se stessi e le loro controparti del caso opposto. Intervallo senza case e non ASCII
i byte corrispondono solo a se stessi.

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

foldEQ_locale
Restituisce true se i byte len iniziali delle stringhe s1 e s2 sono lo stesso caso-
insensibile nella locale corrente; falso altrimenti.

I32 foldEQ_locale(const carattere* a, const carattere* b,
I32 lente)

form Accetta un modello di formato in stile sprintf e argomenti convenzionali (non SV) e
restituisce la stringa formattata.

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

può essere utilizzato ovunque sia richiesta una stringa (char *):

char * s = Perl_form("%d.%d",maggiore,minore);

Utilizza un singolo buffer privato, quindi se vuoi formattare più stringhe devi
copia esplicitamente le stringhe precedenti (e libera le copie quando hai finito).

char* form(const char* pat, ...)

getcwd_sv
Riempi la sv con la directory di lavoro corrente

int getcwd_sv(SV*sv)

get_c_backtrace_dump
Restituisce un SV un dump di |depth| frame dello stack di chiamate, saltando |skip|
quelli più interni. di solito è sufficiente una profondità di 20.

L'output aggiunto è simile a:

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

I campi sono separati da tabulazioni. La prima colonna è la profondità (zero essendo il
frame più interno non saltato). In hex:offset, l'hex è dove si trova il programma
counter era in S_parse_body e :offset (potrebbe mancare) dice quanto
all'interno di S_parse_body c'era il contatore del programma.

util.c:1716 è il file del codice sorgente e il numero di riga.

Le /usr/bin/perl è ovvio (si spera).

Gli sconosciuti sono "-". Le incognite possono capitare purtroppo abbastanza facilmente: se la piattaforma
non supporta il recupero delle informazioni; se al binario manca il debug
informazione; se l'ottimizzatore ha trasformato il codice, ad esempio inlining.

SV* get_c_backtrace_dump(int max_depth, int salta)

ibcmp Questo è un sinonimo di (! piegaEQ())

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

ibcmp_locale
Questo è sinonimo di (! foldEQ_locale())

I32 ibcmp_locale(const carattere* a, const carattere* b,
I32 lente)

is_safe_syscall
Verifica che il dato "pv" non contenga alcun carattere "NUL" interno. Se esso
fa, imposta "errno" su ENOENT, facoltativamente avverte e restituisce FALSE.

Restituisce TRUE se il nome è sicuro.

Utilizzato dal IS_SAFE_SYSCALL() macro.

bool is_safe_syscall(const char *pv, STRLEN len,
const char *cosa,
const carattere *op_name)

memEQ Testa due buffer (che possono contenere caratteri "NUL" incorporati, per vedere se lo sono
pari. Il parametro "len" indica il numero di byte da confrontare. ritorna
zero se uguale o diverso da zero se diverso.

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

memNE Testa due buffer (che possono contenere caratteri "NUL" incorporati, per vedere se lo sono
non uguale. Il parametro "len" indica il numero di byte da confrontare. ritorna
zero se diverso o diverso da zero se uguale.

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

pasticcio Prendi un modello di formato in stile sprintf e un elenco di argomenti. Questi sono usati per generare
un messaggio di stringa. Se il messaggio non termina con una nuova riga, lo sarà
esteso con qualche indicazione della posizione attuale nel codice, come descritto
per "mess_sv".

Normalmente, il messaggio risultante viene restituito in un nuovo SV mortale. Durante globale
distruzione un singolo SV può essere condiviso tra gli usi di questa funzione.

SV * pasticcio(const char *pat, ...)

mess_sv Espande un messaggio, destinato all'utente, per includere un'indicazione della corrente
posizione nel codice, se il messaggio non appare già completo.

"basemsg" è il messaggio o l'oggetto iniziale. Se è un riferimento, verrà utilizzato
così com'è e sarà il risultato di questa funzione. Altrimenti è usato come una stringa,
e se termina già con una nuova riga, è considerata completa e il risultato
di questa funzione sarà la stessa stringa. Se il messaggio non termina con a
newline, quindi verrà aggiunto un segmento come "at foo.pl line 37" e possibilmente
altre clausole indicanti lo stato attuale di esecuzione. Il messaggio risultante
terminerà con un punto e una nuova riga.

Normalmente, il messaggio risultante viene restituito in un nuovo SV mortale. Durante globale
distruzione un singolo SV può essere condiviso tra gli usi di questa funzione. Se "consumare"
è true, la funzione può (ma non richiesta) modificare e restituire
"basemsg" invece di allocare un nuovo SV.

SV * mess_sv(SV *basemsg, bool consuma)

mio_snprintf
La funzionalità "snprintf" della libreria C, se disponibile e conforme agli standard (usa
"vsnprintf", in realtà). Tuttavia, se "vsnprintf" non è disponibile, lo farà
sfortunatamente usa il non sicuro "vsprintf" che può sovraccaricare il buffer (c'è un file
controllo di superamento, ma potrebbe essere troppo tardi). Prendi in considerazione l'utilizzo di "sv_vcatpvf" o
ottenendo "vsnprintf".

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

mio_sprintf
La libreria C "sprintf", avvolta se necessario, per assicurarsi che restituirà il file
lunghezza della stringa scritta nel buffer. Solo rari sistemi pre-ANSI necessitano del
funzione wrapper - di solito questa è una chiamata diretta a "sprintf".

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

mio_strlcat
La libreria C "strlcat" se disponibile, o una sua implementazione Perl. Questo
opera su stringhe C con terminazione "NUL".

"my_strlcat()" aggiunge la stringa "src" alla fine di "dst". Si aggiungerà al massimo
"size - strlen(dst) - 1" caratteri. Quindi terminerà "NUL", a meno che "dimensione"
è 0 o la stringa "dst" originale era più lunga di "size" (in pratica dovrebbe
non succede in quanto significa che "dimensione" non è corretta o che "dst" non è a
stringa con terminazione "NUL" corretta).

Si noti che "dimensione" è la dimensione completa del buffer di destinazione e il risultato è
garantito per essere terminato "NUL" se c'è spazio. Nota quella stanza per il "NUL"
dovrebbe essere incluso in "dimensione".

Size_t mio_strlcat(char *dst, const char *src,
Taglia_t taglia)

mio_strlcpy
La libreria C "strlcpy" se disponibile, o una sua implementazione Perl. Questo
opera su stringhe C con terminazione "NUL".

"my_strlcpy()" copia fino a "size - 1" caratteri dalla stringa "src" a "dst",
"NUL"-termina il risultato se "size" non è 0.

Size_t my_strlcpy(char *dst, const char *src,
Taglia_t taglia)

my_vsnprintf
La libreria C "vsnprintf" se disponibile e conforme agli standard. Tuttavia, se se
il "vsnprintf" non è disponibile, purtroppo utilizzerà il non sicuro "vsprintf"
che può sovraccaricare il buffer (c'è un controllo di sovraccarico, ma potrebbe esserlo anche
tardi). Prendi in considerazione l'utilizzo di "sv_vcatpvf" o di ottenere "vsnprintf".

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

PERL_SYS_INIT
Fornisce l'ottimizzazione specifica del sistema dell'ambiente di runtime C necessario per l'esecuzione
Interpreti Perl. Questo dovrebbe essere chiamato solo una volta, prima di creare qualsiasi Perl
interpreti.

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

PERL_SYS_INIT3
Fornisce l'ottimizzazione specifica del sistema dell'ambiente di runtime C necessario per l'esecuzione
Interpreti Perl. Questo dovrebbe essere chiamato solo una volta, prima di creare qualsiasi Perl
interpreti.

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

PERL_SYS_TERM
Fornisce la pulizia specifica del sistema dell'ambiente di runtime C dopo l'esecuzione di Perl
interpreti. Questo dovrebbe essere chiamato solo una volta, dopo aver liberato qualsiasi Perl rimanente
interpreti.

vuoto PERL_SYS_TERM()

quadmath_format_necessario
quadmath_format_needed() restituisce true se la stringa di formato sembra contenere at
almeno un identificatore di formato %[efgaEFGA] senza prefisso Q, altrimenti restituisce false.

Il rilevamento dell'identificatore di formato non è il rilevamento completo della sintassi printf, ma lo è
dovrebbe catturare i casi più comuni.

Se viene restituito true, quegli argomenti dovrebbero in teoria essere elaborato con
quadmath_snprintf(), ma nel caso in cui vi sia più di uno di questi identificatori di formato (vedi
"quadmath_format_single"), e se c'è qualcos'altro oltre a quello (even
solo un singolo byte), essi non può essere elaborato perché quadmath_snprintf() è molto
rigoroso, accettando solo una specifica di formato e nient'altro. In questo caso, il codice
dovrebbe probabilmente fallire.

bool quadmath_format_needed(const char* formato)

quadmath_format_single
quadmath_snprintf() è molto severo riguardo alla sua stringa di formato e fallirà,
restituendo -1, se il formato non è valido. Accetta esattamente una specifica di formato.

quadmath_format_single() controlla che la specifica singola prevista appaia sana: inizia
con "%", ha solo un "%", termina con "[efgaEFGA]" e ha "Q" prima di esso. Questo
non è un "controllo della sintassi printf" completo, solo le basi.

Restituisce il formato se è valido, NULL in caso contrario.

quadmath_format_single() può e verrà effettivamente patchato nella "Q" mancante, se
necessario. In questo caso restituirà la copia modificata del formato, quale , il
visitatore andrete a bisogno a gratuito.

Vedi anche "quadmath_format_needed".

const char* quadmath_format_single(const char* formato)

LEGGI_XDIGIT
Restituisce il valore di una cifra esadecimale dell'intervallo ASCII e fa avanzare il puntatore della stringa.
Il comportamento è ben definito solo quando isXDIGIT(*str) è true.

U8 READ_XDIGIT(charstr*)

strEQ Prova due stringhe per vedere se sono uguali. Restituisce vero o falso.

bool strEQ(char* s1, char* s2)

strGE Prova due stringhe per vedere se la prima, "s1", è maggiore o uguale a
secondo, "s2". Restituisce vero o falso.

bool strGE(char* s1, char* s2)

strGT Prova due stringhe per vedere se la prima, "s1", è maggiore della seconda, "s2".
Restituisce vero o falso.

bool strGT(char* s1, char* s2)

strLE Prova due stringhe per vedere se la prima, "s1", è minore o uguale alla seconda,
"s2". Restituisce vero o falso.

bool strLE(char* s1, char* s2)

strLT Prova due stringhe per vedere se la prima, "s1", è minore della seconda, "s2".
Restituisce vero o falso.

bool strLT(char* s1, char* s2)

strNE Testare due stringhe per vedere se sono diverse. Restituisce vero o falso.

bool strNE(char* s1, char* s2)

strnEQ Testa due stringhe per vedere se sono uguali. Il parametro "len" indica il
numero di byte da confrontare. Restituisce vero o falso. (Un wrapper per "strncmp").

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

strnNE Testare due stringhe per vedere se sono diverse. Il parametro "len" indica il
numero di byte da confrontare. Restituisce vero o falso. (Un wrapper per "strncmp").

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

sv_distruggibile
Routine fittizia che segnala che l'oggetto può essere distrutto quando non c'è condivisione
modulo presente. Ignora il suo singolo argomento SV e restituisce "true". Esiste per
evitare il test per un puntatore a funzione NULL e perché potrebbe potenzialmente avvertire sotto
un certo livello di rigore.

bool sv_distruttibile(SV *sv)

sv_nosharing
Routine fittizia che "condivide" un SV quando non è presente alcun modulo di condivisione. O
lo "blocca". O lo "sblocca". In altre parole, ignora il suo singolo argomento SV.
Esiste per evitare il test per un puntatore a funzione NULL e perché potrebbe potenzialmente
avvertire sotto un certo livello di severità.

void sv_nosharing(SV *sv)

vmess "pat" e "args" sono un modello di formato in stile sprintf e un argomento incapsulato
elenco. Questi vengono utilizzati per generare un messaggio di stringa. Se il messaggio non finisce
con una nuova riga, poi verrà estesa con qualche indicazione della corrente
posizione nel codice, come descritto per "mess_sv".

Normalmente, il messaggio risultante viene restituito in un nuovo SV mortale. Durante globale
distruzione un singolo SV può essere condiviso tra gli usi di questa funzione.

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

MRO funzioni

Queste funzioni sono correlate all'ordine di risoluzione dei metodi delle classi perl

mro_get_linear_isa
Restituisce la linearizzazione mro per la scorta data. Per impostazione predefinita, questo sarà
qualunque cosa "mro_get_linear_isa_dfs" restituisca a meno che non sia in vigore qualche altro MRO
la scorta. Il valore restituito è un AV* di sola lettura.

Sei responsabile di "SvREFCNT_inc()" sul valore restituito se prevedi di archiviare
ovunque in modo semi-permanente (altrimenti potrebbe essere cancellato da sotto di te il
la prossima volta che la cache viene invalidata).

AV* mro_get_linear_isa(HV* scorta)

mro_metodo_cambiato_in
Invalida la memorizzazione nella cache del metodo su qualsiasi classe figlio della scorta data, in modo che
potrebbe notare i cambiamenti in questo.

Idealmente, tutte le istanze di "PL_sub_generation++" nel sorgente perl al di fuori di mro.c
dovrebbe essere sostituito da inviti a questo.

Perl gestisce automaticamente la maggior parte dei modi comuni in cui un metodo potrebbe essere ridefinito.
Tuttavia, ci sono alcuni modi in cui potresti cambiare un metodo in una scorta senza il
notando il codice della cache, nel qual caso è necessario chiamare questo metodo in seguito:

1) Manipolazione diretta delle voci HV nascoste dal codice XS.

2) Assegnare un riferimento a una costante scalare di sola lettura in una voce di scorta in ordine
per creare una subroutine costante (come fa constant.pm).

Questo stesso metodo è disponibile da pure perl tramite,
"mro::method_changed_in(classname)".

void mro_method_changed_in(HV* scorta)

mro_register
Registra un plug-in mro personalizzato. Vedere perlmroapi per i dettagli.

void mro_register(const struct mro_alg *mro)

Multichiamata funzioni

dMULTICAL
Dichiara le variabili locali per una multicall. Vedi "RICHIAMATE PIÙ LEGGERE" in perlcall.

dMULTICAL;

MULTICHIAMATA
Effettua una richiamata leggera. Vedi "RICHIAMATE PIÙ LEGGERE" in perlcall.

MULTICHIAMATA;

POP_MULTICAL
Staffa di chiusura per una richiamata leggera. Vedere "RICHIAMATE SEMPLICI" in
perlcall.

POP_MULTICAL;

PUSH_MULTICAL
Staffa di apertura per una richiamata leggera. Vedere "RICHIAMATE SEMPLICI" in
perlcall.

PUSH_MULTICALALL;

Numerico funzioni

grok_bin
converte una stringa che rappresenta un numero binario in forma numerica.

In entrata inizia a e a * len dai la stringa da scansionare, *bandiere fornisce flag di conversione,
e a colpevole dovrebbe essere NULL o un puntatore a un NV. La scansione si interrompe alla fine del
stringa o il primo carattere non valido. A meno che non sia impostato "PERL_SCAN_SILENT_ILLDIGIT".
in *bandiere, l'incontro con un carattere non valido attiverà anche un avviso. SU
ritorno * len è impostato sulla lunghezza della stringa scansionata, e *bandiere dà output
bandiere.

Se il valore è <= "UV_MAX" viene restituito come UV, i flag di output sono azzerati,
e nulla è scritto *risultato. Se il valore è > UV_MAX "grok_bin" restituisce
UV_MAX, imposta "PERL_SCAN_GREATER_THAN_UV_MAX" nei flag di output e scrive il
valore a *risultato (oppure il valore viene scartato se colpevole è zero).

Il numero binario può essere opzionalmente preceduto da "0b" o "b" a meno che
"PERL_SCAN_DISALLOW_PREFIX" è impostato in *bandiere in entrata. Se
"PERL_SCAN_ALLOW_UNDERSCORES" è impostato in *bandiere quindi il numero binario può utilizzare '_'
caratteri per separare le cifre.

UV grok_bin(const char* inizio, STRLEN* len_p,
I32* flag, NV *risultato)

grok_hex
converte una stringa che rappresenta un numero esadecimale in formato numerico.

In entrata inizia a e a *len_p dai la stringa da scansionare, *bandiere fornisce flag di conversione,
e a colpevole dovrebbe essere NULL o un puntatore a un NV. La scansione si interrompe alla fine del
stringa o il primo carattere non valido. A meno che non sia impostato "PERL_SCAN_SILENT_ILLDIGIT".
in *bandiere, l'incontro con un carattere non valido attiverà anche un avviso. SU
ritorno * len è impostato sulla lunghezza della stringa scansionata, e *bandiere dà output
bandiere.

Se il valore è <= UV_MAX viene restituito come UV, i flag di output sono azzerati e
non viene scritto nulla *risultato. Se il valore è > UV_MAX, viene restituito "grok_hex".
UV_MAX, imposta "PERL_SCAN_GREATER_THAN_UV_MAX" nei flag di output e scrive il
valore a *risultato (oppure il valore viene scartato se colpevole è zero).

Il numero esadecimale può opzionalmente essere preceduto da "0x" o "x" a meno che
"PERL_SCAN_DISALLOW_PREFIX" è impostato in *bandiere in entrata. Se
"PERL_SCAN_ALLOW_UNDERSCORES" è impostato in *bandiere quindi il numero esadecimale può utilizzare '_'
caratteri per separare le cifre.

UV grok_hex(const char* start, STRLEN* len_p,
I32* flag, NV *risultato)

grok_infnan
Aiutante per numero_grok(), accetta vari modi di scrivere "infinito" o "non a
numero", e restituisce una delle seguenti combinazioni di flag:

IS_NUMBER_INFINITO
È_NUMBER_NAN
IS_NUMBER_INFINITE | IS_NUMBER_NEG
IS_NUMBER_NAN | IS_NUMBER_NEG
0

possibilmente |-ed con IS_NUMBER_TRAILING.

Se viene riconosciuto un infinito o un non-numero, *sp punterà a un byte
oltre la fine della stringa riconosciuta. Se il riconoscimento fallisce, lo è zero
restituito e *sp non si sposterà.

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

numero_grok
Uguale a numero_grok_flags() con flag a zero.

int numero_grok(const char *pv, STRLEN len,
UV *valorep)

numero_grok_flags
Riconosci (o meno) un numero. Viene restituito il tipo del numero (0 se
non riconosciuto), altrimenti è una combinazione di bit OR di IS_NUMBER_IN_UV,
IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT, IS_NUMBER_NEG,
IS_NUMBER_INFINITY, IS_NUMBER_NAN (definito in perl.h).

Se il valore del numero può rientrare in un UV, viene restituito in *valuep
IS_NUMBER_IN_UV verrà impostato per indicare che *valuep è valido, IS_NUMBER_IN_UV
non verrà mai impostato a meno che *valuep non sia valido, ma *valuep potrebbe essere stato assegnato a
durante l'elaborazione anche se IS_NUMBER_IN_UV non è impostato alla restituzione. Se valuep è
NULL, IS_NUMBER_IN_UV verrà impostato per gli stessi casi di quando valuep è diverso da NULL,
ma non si verificherà alcuna assegnazione effettiva (o SEGV).

IS_NUMBER_NOT_INT verrà impostato con IS_NUMBER_IN_UV se sono stati visualizzati decimali finali
(nel qual caso *valuep fornisce il valore vero troncato a un numero intero), e
IS_NUMBER_NEG se il numero è negativo (in tal caso *valuep contiene l'assoluto
valore). IS_NUMBER_IN_UV non è impostato se è stata utilizzata la notazione e o il numero è maggiore
rispetto a un UV.

"flags" consente solo "PERL_SCAN_TRAILING", che consente il trascinamento non numerico
testo su un altrimenti riuscito Grok, impostando "IS_NUMBER_TRAILING" sul risultato.

int grok_number_flags(const char *pv, STRLEN len,
UV *valuep, bandiere U32)

grok_numeric_radix
Cerca e salta per un separatore decimale numerico (radice).

bool grok_numeric_radix(const char **sp,
const char *invia)

grok_ott
converte una stringa che rappresenta un numero ottale in forma numerica.

In entrata inizia a e a * len dai la stringa da scansionare, *bandiere fornisce flag di conversione,
e a colpevole dovrebbe essere NULL o un puntatore a un NV. La scansione si interrompe alla fine del
stringa o il primo carattere non valido. A meno che non sia impostato "PERL_SCAN_SILENT_ILLDIGIT".
in *bandiere, anche l'incontro con un 8 o un 9 attiverà un avviso. Al ritorno * len is
impostare la lunghezza della stringa scansionata, e *bandiere fornisce flag di output.

Se il valore è <= UV_MAX viene restituito come UV, i flag di output sono azzerati e
non viene scritto nulla *risultato. Se il valore è > UV_MAX, viene restituito "grok_oct".
UV_MAX, imposta "PERL_SCAN_GREATER_THAN_UV_MAX" nei flag di output e scrive il
valore a *risultato (oppure il valore viene scartato se colpevole è zero).

Se "PERL_SCAN_ALLOW_UNDERSCORES" è impostato in *bandiere quindi può essere utilizzato il numero ottale
'_' caratteri per separare le cifre.

UV grok_oct(const char* inizio, STRLEN* len_p,
I32* flag, NV *risultato)

isinnan
Perl_isinfnan() è una funzione di utilità che restituisce true se l'argomento NV è uno dei due
un infinito o un NaN, altrimenti falso. Per testare in modo più dettagliato, utilizzare Perl_isinf()
e a Perl_isnan().

Questo è anche l'inverso logico di Perl_isfinito().

bool isinfnan(NV nv)

Perl_signbit
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Restituisce un numero intero diverso da zero se il bit del segno su un NV è impostato e 0 se non lo è.

Se Configure rileva che questo sistema ha un segno () che funzionerà con le nostre NV, quindi
lo usiamo semplicemente tramite #define in perl.h. Altrimenti, ripiega su questo
implementazione. L'uso principale di questa funzione è catturare -0.0.

Configura note: questa funzione è chiamata 'Perl_signbit' invece di semplice
'signbit' perché è facile immaginare un sistema con a segno () funzione o
macro che non funziona con la nostra particolare scelta di NV. Non dovremmo
basta ridefinire signbit come Perl_signbit e aspettarsi che le intestazioni di sistema standard lo facciano
siate felici. Inoltre, questa è una funzione no-context (no pTHX_) perché Perl_signbit()
di solito viene ri-#definito in perl.h come una semplice chiamata macro al sistema segno ().
Gli utenti dovrebbero sempre chiamare Perl_signbit().

int Perl_signbit(NV f)

scan_bin
Per compatibilità con le versioni precedenti. Usa invece "grok_bin".

NV scan_bin(const carattere* inizio, STRLEN len,
STRLEN* ritratta)

scan_hex
Per compatibilità con le versioni precedenti. Usa invece "grok_hex".

NV scan_hex(const char* inizio, STRLEN len,
STRLEN* ritratta)

scan_ott
Per compatibilità con le versioni precedenti. Usa invece "grok_oct".

NV scan_oct(const char* inizio, STRLEN len,
STRLEN* ritratta)

Obsoleto indietro compatibilità funzioni

Alcuni di questi sono anche deprecati. Puoi escluderli dal tuo Perl compilato tramite
aggiungendo questa opzione a Configura: "-Accflags='-DNO_MATHOMS'"

custom_op_desc
Restituisce la descrizione di una determinata operazione personalizzata. Questo era una volta utilizzato dall'OP_DESC
macro, ma non lo è più: è stato mantenuto solo per compatibilità e non dovrebbe
essere usato.

const char * custom_op_desc(const OP *o)

nome_operativo_personalizzato
Restituisce il nome per una determinata operazione personalizzata. Questo era una volta utilizzato dalla macro OP_NAME,
ma non lo è più: è stato conservato solo per compatibilità e non dovrebbe essere utilizzato.

const char * nome_op_personalizzato(OP const *o)

gv_fetchmethod
Vedere "gv_fetchmethod_autoload".

GV* gv_fetchmethod(HV* scorta, const char* nome)

is_utf8_char
DEPRECATO! Si prevede di rimuovere questa funzione da una futura versione di Perl.
Non usarlo per il nuovo codice; rimuoverlo dal codice esistente.

Verifica se un numero arbitrario di byte inizia in un carattere UTF-8 valido. Nota
che un carattere INVARIANT (cioè ASCII su macchine non EBCDIC) è un UTF-8 valido
carattere. Il numero effettivo di byte nel carattere UTF-8 verrà restituito se
è valido, altrimenti 0.

Questa funzione è deprecata a causa della possibilità che l'input non sia corretto
causare la lettura oltre la fine del buffer di input. Utilizzare invece "isUTF8_CHAR".

STRLEN is_utf8_char(const U8 *s)

is_utf8_char_buf
Questo è identico alla macro "isUTF8_CHAR".

STRLEN is_utf8_char_buf(const U8 *buf,
const U8 *buff_end)

pack_cat
L'implementazione del motore pacchetto() funzione Perl. Nota: parametri next_in_list e
le bandiere non vengono utilizzate. Questa chiamata non deve essere utilizzata; usa invece la lista dei pacchetti.

void pack_cat(SV *cat, const char *pat,
const carattere *patend, SV **beglist,
SV **endlist, SV ***next_in_list,
bandiere U32)

pad_nomecomp_tipo
Cerca il tipo della variabile lessicale in posizione po nell'attuale-
blocco di compilazione. Se la variabile è digitata, la scorta della classe a cui appartiene
digitato viene restituito. In caso contrario, viene restituito "NULL".

HV * pad_compname_type(PADOFFSET po)

sv_2pvbyte_nolen
Restituisce un puntatore alla rappresentazione codificata in byte dell'SV. Può causare la SV
essere declassato da UTF-8 come effetto collaterale.

Di solito si accede tramite la macro "SvPVbyte_nolen".

char* sv_2pvbyte_nolen(SV* sv)

sv_2pvutf8_nolen
Restituisce un puntatore alla rappresentazione con codifica UTF-8 dell'SV. Può causare la SV
da aggiornare a UTF-8 come effetto collaterale.

Di solito si accede tramite la macro "SvPVutf8_nolen".

char* sv_2pvutf8_nolen(SV* sv)

sv_2pv_nolen
Come "sv_2pv()", ma non restituisce anche la lunghezza. Di solito dovresti usare il
invece il macro wrapper "SvPV_nolen(sv)".

char* sv_2pv_nolen(SV* sv)

sv_catpvn_mg
Come "sv_catpvn", ma gestisce anche la magia "set".

void sv_catpvn_mg(SV *sv, const char *ptr,
STRLEN lente)

sv_catsv_mg
Come "sv_catsv", ma gestisce anche la magia "set".

void sv_catsv_mg(SV *dsv, SV *ssv)

sv_force_normal
Annulla vari tipi di fake su un SV: se il PV è una stringa condivisa, fare a
copia privata; se siamo un referente, smetti di fare riferimento; se siamo un glob, esegui il downgrade a un xpvmg.
Vedi anche "sv_force_normal_flags".

void sv_forza_normal(SV *sv)

sv_iv Un'implementazione privata della macro "SvIVx" per compilatori che non possono farcela
espressioni macro complesse. Utilizzare sempre invece la macro.

IV sv_iv(SV* sv)

sv_nolocking
Routine fittizia che "blocca" un SV quando non è presente alcun modulo di blocco. Esiste
per evitare il test per un puntatore a funzione NULL e perché potrebbe potenzialmente avvisare
sotto un certo livello di rigore.

"Sostituito" da sv_nosharing().

void sv_nolocking(SV *sv)

sv_nomeunlocking
Routine fittizia che "sblocca" un SV quando non è presente alcun modulo di blocco.
Esiste per evitare il test per un puntatore a funzione NULL e perché potrebbe potenzialmente
avvertire sotto un certo livello di severità.

"Sostituito" da sv_nosharing().

void sv_nomeunlocking(SV *sv)

sv_nv Un'implementazione privata della macro "SvNVx" per compilatori che non possono far fronte a
espressioni macro complesse. Utilizzare sempre invece la macro.

NV sv_nv(SV* sv)

sv_pv Utilizzare invece la macro "SvPV_nolen".

char* sv_pv(SV *sv)

sv_pvbyte
Usa invece "SvPVbyte_nolen".

char* sv_pvbyte(SV *sv)

sv_pvbyten
Un'implementazione privata della macro "SvPVbyte" per i compilatori che non possono farcela
con espressioni macro complesse. Utilizzare sempre invece la macro.

char* sv_pvbyten(SV *sv, STRLEN *lp)

sv_pvn Un'implementazione privata della macro "SvPV" per compilatori che non possono far fronte a
espressioni macro complesse. Utilizzare sempre invece la macro.

char* sv_pvn(SV *sv, STRLEN *lp)

sv_pvutf8
Utilizzare invece la macro "SvPVutf8_nolen".

carattere* sv_pvutf8(SV *sv)

sv_pvutf8n
Un'implementazione privata della macro "SvPVutf8" per i compilatori che non possono farcela
con espressioni macro complesse. Utilizzare sempre invece la macro.

char* sv_pvutf8n(SV *sv, STRLEN *lp)

sv_contagio
Contamina un SV. Usa invece "SvTAINTED_on".

void sv_taint(SV* sv)

sv_unref
Disattiva lo stato RV dell'SV e decrementa il conteggio di riferimento di qualunque cosa fosse
essere referenziato dal RV. Questo può quasi essere pensato come un capovolgimento di
"nuovoSVrv". Questo è "sv_unref_flags" con il "flag" zero. Vedere "SvROK_off".

void sv_unref(SV* sv)

sv_usepvn
Dice a un SV di usare "ptr" per trovare il suo valore di stringa. Implementato chiamando
"sv_usepvn_flags" con "flags" di 0, quindi non gestisce la magia "set". Vedere
"sv_usepvn_flags".

void sv_usepvn(SV* sv, char* ptr, STRLEN len)

sv_usepvn_mg
Come "sv_usepvn", ma gestisce anche la magia "set".

void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)

sv_uv Un'implementazione privata della macro "SvUVx" per compilatori che non possono farcela
espressioni macro complesse. Utilizzare sempre invece la macro.

UVsv_uv(SV*sv)

decomprimere_str
L'implementazione del motore scompattare() funzione Perl. Nota: parametri strbeg, new_s
e ocnt non vengono utilizzati. Questa chiamata non dovrebbe essere usata, usa invece unpackstring.

I32 unpack_str(const char *pat, const char *patend,
const carattere *s, const carattere *strbeg,
const carattere *tendenza, carattere **new_s,
I32 ott, bandiere U32)

utf8_to_uvchr
DEPRECATO! Si prevede di rimuovere questa funzione da una futura versione di Perl.
Non usarlo per il nuovo codice; rimuoverlo dal codice esistente.

Restituisce il punto di codice nativo del primo carattere nella stringa "s" che è
si presume che sia nella codifica UTF-8; "retlen" sarà impostato sulla lunghezza, in byte, di
quel personaggio.

Alcune, ma non tutte, le malformazioni UTF-8 vengono rilevate e, in effetti, alcune malformate
input potrebbe causare la lettura oltre la fine del buffer di input, motivo per cui questo
la funzione è deprecata. Usa invece "utf8_to_uvchr_buf".

Se "s" punta a una delle malformazioni rilevate e gli avvisi UTF8 sono abilitati,
zero viene restituito e *retlen viene impostato (se "retlen" non è NULL) su -1. Se quelli
gli avvisi sono disattivati, il valore calcolato se ben definito (o Unicode REPLACEMENT
CHARACTER, in caso contrario) viene restituito silenziosamente e *retlen è impostato (se "retlen" non è
NULL) in modo che ("s" + *retlen) sia la prossima posizione possibile in "s" che potrebbe
iniziare un carattere non malformato. Vedi "utf8n_to_uvchr" per i dettagli su quando il
Viene restituito il CARATTERE DI SOSTITUZIONE.

UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)

utf8_to_uvuni
DEPRECATO! Si prevede di rimuovere questa funzione da una futura versione di Perl.
Non usarlo per il nuovo codice; rimuoverlo dal codice esistente.

Restituisce il punto di codice Unicode del primo carattere nella stringa "s" che è
si presume che sia nella codifica UTF-8; "retlen" sarà impostato sulla lunghezza, in byte, di
quel personaggio.

Alcune, ma non tutte, le malformazioni UTF-8 vengono rilevate e, in effetti, alcune malformate
input potrebbe causare la lettura oltre la fine del buffer di input, che è una delle ragioni
perché questa funzione è deprecata. L'altro è che solo in estremamente limitato
circostanze dovrebbero interessare il punto di codice Unicode rispetto a quello nativo
voi. Vedere "utf8_to_uvuni_buf" per le alternative.

Se "s" punta a una delle malformazioni rilevate e gli avvisi UTF8 sono abilitati,
zero viene restituito e *retlen viene impostato (se "retlen" non punta a NULL) su -1. Se
quegli avvisi sono disattivati, il valore calcolato se ben definito (o Unicode
CARATTERE DI SOSTITUZIONE, in caso contrario) viene restituito silenziosamente e viene impostato *retlen (se
"retlen" non è NULL) quindi ("s" + *retlen) è la prossima posizione possibile in "s"
che potrebbe iniziare un carattere non malformato. Vedere "utf8n_to_uvchr" per i dettagli su
quando viene restituito il CARATTERE DI SOSTITUZIONE.

UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)

Optree costruzione

nuovoASSIGNOP
Costruisce, controlla e restituisce un'assegnazione op. a sinistra e a diritto fornire il
parametri dell'incarico; vengono consumati da questa funzione e diventano parte
dell'albero op costruito.

If tipo ottuso è "OP_ANDASSIGN", "OP_ORASSIGN" o "OP_DORASSIGN", quindi un adatto
viene costruito l'optree condizionale. Se tipo ottuso è il codice operativo di un operatore binario,
come "OP_BIT_OR", quindi viene costruito un op che esegue l'operazione binaria
e assegna il risultato all'argomento di sinistra. Ad ogni modo, se tipo ottuso è diverso da zero
poi bandiere non ha effetto.

If tipo ottuso è zero, quindi viene costruita una semplice assegnazione scalare o di elenco. Quale
il tipo di incarico è determinato automaticamente. bandiere dà gli otto bit
di "op_flags", tranne per il fatto che "OPf_KIDS" verrà impostato automaticamente e, spostato verso l'alto
otto bit, gli otto bit di "op_private", tranne che il bit con valore 1 o 2
viene impostato automaticamente come richiesto.

OP * newASSIGNOP(I32 flag, OP *left, I32 optype,
OP *destra)

nuovoBINOP
Costruisce, controlla e restituisce un'operazione di qualsiasi tipo binario. Digitare è il codice operativo.
bandiere fornisce gli otto bit di "op_flags", tranne per il fatto che verrà impostato "OPf_KIDS".
automaticamente e, spostati di otto bit, gli otto bit di "op_private", eccetto
che il bit con valore 1 o 2 venga impostato automaticamente come richiesto. prima di tutto e a ultimo
fornire fino a due operazioni come figli diretti dell'operazione binaria; sono consumati
da questa funzione e diventano parte dell'op tree costruito.

OP * newBINOP(tipo I32, flag I32, OP *first,
OP *ultimo)

nuovoCONDOP
Costruisce, controlla e restituisce un'espressione condizionale ("cond_expr") op. bandiere
fornisce gli otto bit di "op_flags", tranne per il fatto che verrà impostato "OPf_KIDS".
automaticamente e, spostati di otto bit, gli otto bit di "op_private", eccetto
che il bit con valore 1 sia impostato automaticamente. prima di tutto fornisce l'espressione
selezionando tra i due rami, e trueop e a falso rifornire le filiali;
vengono consumati da questa funzione e diventano parte dell'op tree costruito.

OP * newCONDOP(flag I32, OP *first, OP *trueop,
OP *falso)

nuovoDEFSVOP
Costruisce e restituisce un op per accedere a $_, sia come variabile lessicale (if
dichiarato come "my $_") nell'ambito corrente o $_ globale.

OP * nuovoDEFSVOP()

nuovoFOROP
Costruisce, controlla e restituisce un albero operativo che esprime un ciclo "foreach" (iterazione
attraverso un elenco di valori). Questo è un anello pesante, con una struttura che lo consente
uscire dal ciclo con "last" e simili.

sv fornisce facoltativamente la variabile che sarà alias a turno per ogni elemento; Se
null, il valore predefinito è $_ (lessicale o globale). espr fornisce l'elenco di
valori su cui ripetere. bloccare fornisce il corpo principale del ciclo, e conto
opzionalmente fornisce un blocco "continua" che funge da seconda metà del corpo.
Tutti questi input optree vengono consumati da questa funzione e diventano parte del
albero op costruito.

bandiere fornisce gli otto bit di "op_flags" per l'op "leaveloop" e, spostato verso l'alto
otto bit, gli otto bit di "op_private" per l'op "leaveloop", tranne che (in
entrambi i casi) alcuni bit verranno impostati automaticamente.

OP * newFOROP(flag I32, OP *sv, OP *expr, OP *blocco,
OP *segue)

nuovoGIVENOP
Costruisce, controlla e restituisce un albero operativo che esprime un blocco "dato". cond
fornisce l'espressione che verrà assegnata localmente a una variabile lessicale, e
bloccare fornisce il corpo del costrutto "dato"; sono consumati da questo
funzionano e diventano parte dell'albero operativo costruito. defsv_off è l'offset del pad
della variabile lessicale scalare che sarà interessata. Se è 0, il $_ globale
verrà utilizzato.

OP * newGIVENOP(OP *cond, OP *blocco,
PADOFFSET defsv_off)

newGVOP Costruisce, controlla e restituisce un'operazione di qualsiasi tipo che implica un embedded
riferimento a un GV. Digitare è il codice operativo. bandiere fornisce gli otto bit di "op_flags".
gv identifica il GV a cui l'op dovrebbe fare riferimento; chiamare questa funzione non lo fa
trasferire la proprietà di qualsiasi riferimento ad essa.

OP * newGVOP(tipo I32, flag I32, GV *gv)

nuovoLISTOP
Costruisce, controlla e restituisce un'operazione di qualsiasi tipo di elenco. Digitare è il codice operativo.
bandiere fornisce gli otto bit di "op_flags", tranne per il fatto che verrà impostato "OPf_KIDS".
automaticamente se richiesto. prima di tutto e a ultimo fornire fino a due operazioni per essere diretti
figli della lista op; vengono consumati da questa funzione e diventano parte del
albero op costruito.

Per la maggior parte degli operatori di elenchi, la funzione di controllo prevede che tutte le operazioni kid siano presenti
già, quindi chiamare "newLISTOP(OP_JOIN, ...)" (ad esempio) non è appropriato. Cosa tu
in tal caso, è necessario creare un'operazione di tipo OP_LIST, aggiungere più figli a
it, quindi chiama "op_convert_list". Vedere "op_convert_list" per ulteriori informazioni.

OP * newLISTOP(tipo I32, flag I32, OP *first,
OP *ultimo)

nuovoLOGOP
Costruisce, controlla e restituisce un'operazione logica (controllo di flusso). Digitare è il codice operativo.
bandiere fornisce gli otto bit di "op_flags", tranne per il fatto che verrà impostato "OPf_KIDS".
automaticamente e, spostati di otto bit, gli otto bit di "op_private", eccetto
che il bit con valore 1 sia impostato automaticamente. prima di tutto fornisce l'espressione
controllare il flusso, e Altro fornisce la catena di operazioni secondarie (alternative); essi
vengono consumati da questa funzione e diventano parte dell'op tree costruito.

OP * newLOGOP(tipo I32, flag I32, OP *first,
OP *altro)

nuovoLOOPEX
Costruisce, controlla e restituisce un'operazione di uscita dal ciclo (come "goto" o "last").
Digitare è il codice operativo. etichetta fornisce il parametro che determina il target del
operazione; viene consumato da questa funzione e diventa parte dell'op tree costruito.

OP * newLOOPEX(tipo I32, OP *etichetta)

nuovoLOOPOP
Costruisce, controlla e restituisce un albero operativo che esprime un ciclo. Questo è solo un ciclo
nel flusso di controllo attraverso l'op tree; non ha il ciclo dei pesi massimi
struttura che permette di uscire dal loop per "last" e simili. bandiere dà
otto bit di "op_flags" per l'operazione di livello superiore, tranne per il fatto che verranno impostati alcuni bit
automaticamente come richiesto. espr fornisce il ciclo di controllo dell'espressione
iterazione, e bloccare fornisce il corpo del ciclo; sono consumati da questo
funzionano e diventano parte dell'albero operativo costruito. debuggabile è attualmente
inutilizzato e dovrebbe essere sempre 1.

OP * newLOOPOP(flag I32, debug I32, OP *expr,
OP *blocco)

nuovoMETHOP
Costruisce, controlla e restituisce un'operazione di tipo di metodo con un nome di metodo valutato
in fase di esecuzione. Digitare è il codice operativo. bandiere fornisce gli otto bit di "op_flags", eccetto
che "OPf_KIDS" verrà impostato automaticamente e, spostati di otto bit in alto, gli otto
bit di "op_private", tranne per il fatto che il bit con valore 1 viene impostato automaticamente.
dinamica_met fornisce un op che valuta il nome del metodo; è consumato da questo
funzionano e diventano parte dell'albero operativo costruito. Opzioni supportate:
OP_METODO.

OP * newMETHOP(tipo I32, flag I32, OP *first)

nuovoMETHOP_nome
Costruisce, controlla e restituisce un'operazione di tipo di metodo con un nome di metodo costante.
Digitare è il codice operativo. bandiere fornisce gli otto bit di "op_flags" e, spostato verso l'alto
otto bit, gli otto bit di "op_private". const_met fornisce un metodo costante
nome; deve essere una stringa COW condivisa. Optypes supportati: OP_METHOD_NAMED.

OP * newMETHOP_named(tipo I32, flag I32,
SV *const_meth)

nuovoNULLLIST
Costruisce, controlla e restituisce una nuova operazione "stub", che rappresenta un elenco vuoto
espressione.

OP * nuovoNULLLIST()

newOP Costruisce, controlla e restituisce un op di qualsiasi tipo di base (qualsiasi tipo che non abbia extra
campi). Digitare è il codice operativo. bandiere fornisce gli otto bit di "op_flags" e,
spostato su otto bit, gli otto bit di "op_private".

OP * newOP (tipo I32, flag I32)

nuovoPADOP
Costruisce, controlla e restituisce un'operazione di qualsiasi tipo che implica un riferimento a a
elemento pad. Digitare è il codice operativo. bandiere fornisce gli otto bit di "op_flags". UN
lo slot del pad viene allocato automaticamente e viene popolato con sv; questa funzione prende
proprietà di un riferimento ad esso.

Questa funzione esiste solo se Perl è stato compilato per usare ithreads.

OP * newPADOP(tipo I32, flag I32, SV *sv)

newPMOP Costruisce, controlla e restituisce un op di qualsiasi tipo di pattern matching. Digitare Europe è
codice operativo. bandiere fornisce gli otto bit di "op_flags" e, spostato in alto di otto bit, il file
otto bit di "op_private".

OP * newPMOP (tipo I32, flag I32)

newPVOP Costruisce, controlla e restituisce un'operazione di qualsiasi tipo che implica un embedded
Puntatore di livello C (PV). Digitare è il codice operativo. bandiere dà gli otto bit di
"op_flags". pv fornisce il puntatore di livello C, che deve essere stato assegnato utilizzando
"PerlMemShared_malloc"; la memoria verrà liberata quando l'operazione verrà distrutta.

OP * newPVOP(tipo I32, flag I32, char *pv)

nuova GAMMA
Costruisce e restituisce un'operazione "range", con operazioni "flip" e "flop" subordinate.
bandiere fornisce gli otto bit di "op_flags" per l'operazione "flip" e, spostato in alto di otto
bit, gli otto bit di "op_private" per entrambe le operazioni "flip" e "range", eccetto
che il bit con valore 1 sia impostato automaticamente. a sinistra e a diritto fornire il
espressioni che controllano gli estremi dell'intervallo; sono consumati da questo
funzionano e diventano parte dell'albero operativo costruito.

OP * newRANGE(I32 flag, OP *sinistra, OP *destra)

novitàSLICEOP
Costruisce, controlla e restituisce un "lslice" (fetta di elenco) op. bandiere dà
otto bit di "op_flags", tranne per il fatto che "OPf_KIDS" verrà impostato automaticamente e,
spostato su otto bit, gli otto bit di "op_private", tranne che il bit con
il valore 1 o 2 viene impostato automaticamente come richiesto. valorelist e a pedice fornire il
parametri della fetta; vengono consumati da questa funzione e diventano parte del
albero op costruito.

OP * newSLICEOP(flag I32, OP *pedice,
OP *valoreelenco)

nuovoSTATEOP
Costruisce un'operazione di stato (COP). L'operazione di stato è normalmente un'operazione "nextstate", ma lo farà
essere un "dbstate" op se il debug è abilitato per il codice attualmente compilato. Lo stato
op è popolato da "PL_curcop" (o "PL_compiling"). Se etichetta è non nullo, esso
fornisce il nome di un'etichetta da allegare all'op di stato; questa funzione prende
proprietà della memoria indicata da etichetta, e lo libererà. bandiere dà
otto bit di "op_flags" per lo stato op.

If o è nullo, viene restituito lo stato op. Altrimenti lo stato op viene combinato con o
in una lista "lineseq" op, che viene restituita. o viene consumato da questa funzione e
diventa parte dell'albero operativo restituito.

OP * newSTATEOP(I32 flag, char *label, OP *o)

newSVOP Costruisce, controlla e restituisce un'operazione di qualsiasi tipo che coinvolge un SV incorporato.
Digitare è il codice operativo. bandiere fornisce gli otto bit di "op_flags". sv dà l'SV a
incorporare nell'op; questa funzione assume la proprietà di un riferimento ad essa.

OP * newSVOP(tipo I32, flag I32, SV *sv)

newUNOP Costruisce, controlla e restituisce un'operazione di qualsiasi tipo unario. Digitare è il codice operativo.
bandiere fornisce gli otto bit di "op_flags", tranne per il fatto che verrà impostato "OPf_KIDS".
automaticamente se richiesto e, spostato in alto di otto bit, gli otto bit di
"op_private", tranne per il fatto che il bit con valore 1 viene impostato automaticamente. prima di tutto
fornisce un'op facoltativa per essere il figlio diretto dell'op unario; è consumato da
questa funzione e diventano parte dell'op tree costruito.

OP * newUNOP (tipo I32, flag I32, OP *first)

nuovoUNOP_AUX
Simile a "newUNOP", ma crea invece una struttura UNOP_AUX, con op_aux
inizializzato su aux

OP* newUNOP_AUX(tipo I32, flag I32, OP* prima,
UNOP_AUX_elemento *aux)

nuovoWHENOP
Costruisce, controlla e restituisce un albero operativo che esprime un blocco "quando". cond
fornisce l'espressione di prova, e bloccare fornisce il blocco che verrà eseguito
se il test risulta vero; vengono consumati da questa funzione e diventano parte
dell'albero op costruito. cond sarà interpretato DWIMicamente, spesso come a
confronto con $ _ e potrebbe essere nullo per generare un blocco "predefinito".

OP * nuovoWHENOP(OP *cond, OP *blocco)

nuovoWHILEOP
Costruisce, controlla e restituisce un albero operativo che esprime un ciclo "while". Questo è un
anello dei pesi massimi, con struttura che permette di uscire dall'anello per "last" e
simile.

loop è un'op "enterloop" precostruita opzionale da usare nel ciclo; se è
null allora un op adatto verrà costruito automaticamente. espr fornisce il
espressione di controllo del ciclo. bloccare fornisce il corpo principale del ciclo, e conto
opzionalmente fornisce un blocco "continua" che funge da seconda metà del corpo.
Tutti questi input optree vengono consumati da questa funzione e diventano parte del
albero op costruito.

bandiere fornisce gli otto bit di "op_flags" per l'op "leaveloop" e, spostato verso l'alto
otto bit, gli otto bit di "op_private" per l'op "leaveloop", tranne che (in
entrambi i casi) alcuni bit verranno impostati automaticamente. debuggabile è attualmente inutilizzato
e dovrebbe essere sempre 1. ha_mio può essere fornito come true per forzare il corpo del loop
essere racchiuso nel proprio ambito.

OP * newWHILEOP(flag I32, debug I32,
LOOP *loop, OP *espr, OP *blocco,
OP *cont, I32 ha_mio)

Optree Manipolazione funzioni

alloccopstash
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Disponibile solo in build con thread, questa funzione alloca una voce in
"PL_stashpad" per la scorta passata.

PADOFFSET alloccopstash(HV *hv)

fine_blocco
Gestisce l'uscita dall'ambito in fase di compilazione. piano è l'indice dello stack di salvataggio restituito da
"blocco_inizio", e ss è il corpo del blocco. Restituisce il blocco, possibilmente
modificata.

OP * block_end(I32 piano, OP *seq)

inizio_blocco
Gestisce la voce dell'ambito in fase di compilazione. Fa in modo che i suggerimenti vengano ripristinati all'uscita dal blocco
e gestisce anche i numeri di sequenza dei pad per rendere corretto l'ambito delle variabili lessicali.
Restituisce un indice savestack da utilizzare con "block_end".

int block_start(int pieno)

ck_entersub_args_list
Esegue la correzione predefinita degli argomenti parte di un albero operativo "entersub". Questo
consiste nell'applicare il contesto dell'elenco a ciascuno degli argomenti ops. Questo è il
trattamento standard utilizzato su una chiamata contrassegnata con "&", o una chiamata di metodo o una chiamata
tramite un riferimento a una subroutine o qualsiasi altra chiamata in cui il chiamato non può essere
identificato in fase di compilazione o una chiamata in cui il chiamato non ha un prototipo.

OP * ck_entersub_args_list(OP *entersubop)

ck_entersub_args_proto
Esegue la correzione degli argomenti parte di un albero operativo "entersub" basato su a
prototipo di sottoprogramma. Ciò apporta varie modifiche all'argomento ops, da
applicando il contesto fino all'inserimento delle operazioni "refgen" e controllando il numero e
tipi sintattici di argomenti, come indicato dal prototipo. Questo è lo standard
trattamento utilizzato su una chiamata di sottoprogramma, non contrassegnata da "&", dove può trovarsi il chiamato
identificato in fase di compilazione e dispone di un prototipo.

protosv fornisce il prototipo di subroutine da applicare alla chiamata. Potrebbe essere un
scalare normale definito, di cui verrà utilizzato il valore stringa. In alternativa, per
convenienza, potrebbe essere un oggetto subroutine (un "CV*" che è stato lanciato su "SV*")
che ha un prototipo. Il prototipo fornito, in qualsiasi forma, non necessita
in modo che corrisponda al chiamato effettivo a cui fa riferimento l'albero operativo.

Se l'argomento ops non è d'accordo con il prototipo, ad esempio avendo un
numero inaccettabile di argomenti, viene comunque restituito un albero operativo valido. L'errore
si riflette nello stato del parser, generando normalmente un'unica eccezione al
livello superiore di analisi che copre tutti gli errori di compilazione che si sono verificati. In
il messaggio di errore, il chiamato viene indicato con il nome definito dal nomegv
parametro.

OP * ck_entersub_args_proto(OP *entersubop,
GV *namegv, SV *protosv)

ck_entersub_args_proto_or_list
Esegue la correzione degli argomenti parte di un albero operativo "entersub" basato su entrambi
un prototipo di subroutine o utilizzando l'elaborazione del contesto di elenco predefinita. Questo è il
trattamento standard utilizzato su una chiamata di sottoprogramma, non contrassegnata da "&", dove il
il chiamato può essere identificato in fase di compilazione.

protosv fornisce il prototipo del sottoprogramma da applicare alla chiamata, o indica
che non esiste un prototipo. Potrebbe essere uno scalare normale, nel qual caso se lo è
definito, il valore della stringa verrà utilizzato come prototipo e, se non è definito
quindi non c'è nessun prototipo. In alternativa, per comodità, può essere a
oggetto subroutine (un "CV*" che è stato convertito in "SV*"), di cui il prototipo
verrà utilizzato se ne ha uno. Il prototipo (o la sua mancanza) fornito, in
qualunque forma, non è necessario che corrisponda all'effettivo chiamato a cui fa riferimento l'op
albero.

Se l'argomento ops non è d'accordo con il prototipo, ad esempio avendo un
numero inaccettabile di argomenti, viene comunque restituito un albero operativo valido. L'errore
si riflette nello stato del parser, generando normalmente un'unica eccezione al
livello superiore di analisi che copre tutti gli errori di compilazione che si sono verificati. In
il messaggio di errore, il chiamato viene indicato con il nome definito dal nomegv
parametro.

OP * ck_entersub_args_proto_or_list(OP *entersubop,
GV *nomegv,
SV *protov)

cv_const_sv
Se "cv" è una sottocostante idonea per l'inline, restituisce il valore costante
restituito dal sub. In caso contrario, restituisce NULL.

I sottotitoli costanti possono essere creati con "newCONSTSUB" o come descritto in "Constant
Funzioni" in perlsub.

SV* cv_const_sv(const CV *const cv)

cv_get_call_checker
Recupera la funzione che verrà utilizzata per correggere una chiamata cv. In particolare,
la funzione viene applicata ad un albero operativo "entersub" per una chiamata di sottoprogramma, non contrassegnato
con "&", dove il chiamato può essere identificato in fase di compilazione come cv.

Viene restituito il puntatore alla funzione di livello C *ckfun_p, e un argomento SV per esso è
tornato in *ckobj_p. La funzione deve essere chiamata in questo modo:

entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p));

In questa chiamata, entrasubop è un puntatore all'operazione "entersub", che può essere sostituita
dalla funzione di controllo, e nomegv è un GV che fornisce il nome da utilizzare
dalla funzione di controllo per fare riferimento al chiamato dell'op "entersub" se necessario
emettere qualsiasi diagnostica. È consentito applicare la funzione di verifica in modalità non standard
situazioni, ad esempio a una chiamata a una subroutine diversa oa una chiamata a un metodo.

Per impostazione predefinita, la funzione è Perl_ck_entersub_args_proto_or_list e l'SV
il parametro è cv si. Ciò implementa l'elaborazione del prototipo standard. Può essere
modificato, per una particolare subroutine, da "cv_set_call_checker".

void cv_get_call_checker(CV *cv,
Perl_call_checker *ckfun_p,
SV **ckobj_p)

cv_set_call_checker
La forma originale di "cv_set_call_checker_flags", che lo passa il
Flag "CALL_CHECKER_REQUIRE_GV" per la compatibilità con le versioni precedenti.

void cv_set_call_checker(CV *cv,
Perl_call_checker ckfun,
SV *ckobj)

cv_set_call_checker_flags
Imposta la funzione che verrà utilizzata per fissare una chiamata cv. In particolare, il
la funzione viene applicata a un albero operativo "entersub" per una chiamata a una subroutine, non contrassegnata
con "&", dove il chiamato può essere identificato in fase di compilazione come cv.

Il puntatore della funzione di livello C è fornito in divertimento, e un argomento SV per esso è
fornito in ckobj. La funzione dovrebbe essere definita in questo modo:

STATICO OP * ckfun(pTHX_ OP *op, GV *namegv, SV *ckobj)

Deve essere chiamato in questo modo:

entersubop = ckfun(aTHX_ entersubop, namegv, ckobj);

In questa chiamata, entrasubop è un puntatore all'operazione "entersub", che può essere sostituita
dalla funzione di controllo, e nomegv fornisce il nome che dovrebbe essere utilizzato dal
check function per fare riferimento al chiamato dell'op "entersub" se ha bisogno di emetterne
diagnostica. È consentito applicare la funzione di verifica in modalità non standard
situazioni, ad esempio a una chiamata a una subroutine diversa oa una chiamata a un metodo.

nomegv potrebbe non essere effettivamente un GV. Per efficienza, perl può passare un CV o un altro SV
invece. Qualunque cosa venga passata può essere usata come primo argomento per "cv_name". Voi
può forzare perl a passare un GV includendo "CALL_CHECKER_REQUIRE_GV" nel file bandiere.

L'impostazione corrente per un particolare CV può essere recuperata da "cv_get_call_checker".

void cv_set_call_checker_flags(
CV *cv, Perl_call_checker ckfun, SV *ckobj,
Bandiere U32
)

ELENCO COLLEGAMENTI
Data la radice di un optree, collegare l'albero in ordine di esecuzione usando "op_next"
puntatori e restituiscono la prima operazione eseguita. Se questo è già stato fatto, lo farà
non essere ripetuto e verrà restituito "o->op_next". Se "o->op_next" non è già
impostato, o dovrebbe essere almeno un "UNOP".

OP* ELENCO COLLEGAMENTI(OP *o)

nuovoCONSTSUB
Vedi "newCONSTSUB_flags".

CV* newCONSTSUB(HV* stash, const char* nome, SV* sv)

nuovoCONSTSUB_flags
Crea una costante sub equivalente a Perl "sub FOO () { 123 }" che è idonea
per l'inlining in fase di compilazione.

Attualmente, l'unico valore utile per i "flags" è SVf_UTF8.

La nuova subroutine assume la proprietà di un riferimento al passato in SV.

Il passaggio di NULL per SV crea una costante sub equivalente a "sub BAR () {}", che
non verrà chiamato se usato come distruttore, ma sopprimerà il sovraccarico di una chiamata
in "AUTOCARICA". (Questo modulo, tuttavia, non è idoneo per l'integrazione in fase di compilazione.)

CV* newCONSTSUB_flags(HV* scorta, const char* nome,
STRLEN len, bandiere U32, SV* sv)

newXS Usato da "xsubpp" per collegare gli XSUB come sottotitoli Perl. Nome del file deve essere statico
stoccaggio, in quanto viene utilizzato direttamente come CvFILE(), senza che ne venga fatta una copia.

OpHAS_SIBLING
Restituisce vero se o ha un fratello

bool OpHAS_SIBLING(OP *o)

OpLASTSIB_set
Contrassegna o come se non avesse altri fratelli. Nelle build "PERL_OP_PARENT", contrassegna o come
avendo il genitore specificato. Vedi anche "OpMORESIB_set" e "OpMAYBESIB_set". Per un
interfaccia di livello superiore, vedere "op_sibling_splice".

void OpLASTSIB_set(OP *o, OP *genitore)

OpMAYBESIB_set
Fa condizionalmente "OpMORESIB_set" o "OpLASTSIB_set" a seconda che sib lo sia
non nullo. Per un'interfaccia di livello superiore, vedere "op_sibling_splice".

void OpMAYBESIB_set(OP *o, OP *sib, OP *genitore)

OpMORESIB_set
Imposta il fratello di o sul valore diverso da zero sib. Vedi anche "OpLASTSIB_set" e
"OpMAYBESIB_set". Per un'interfaccia di livello superiore, vedere "op_sibling_splice".

void OpMORESIB_set(OP *o, OP *sib)

OPSIBLING
Restituisce il fratello di o, o NULL se non c'è un fratello

OP* OPSIBLING(OP *o)

op_append_elem
Aggiungi un elemento all'elenco delle operazioni contenute direttamente all'interno di un'operazione di tipo elenco,
restituendo l'elenco allungato. prima di tutto è il tipo di elenco op, e ultimo è l'opzione per
aggiungere all'elenco. tipo ottuso specifica il codice operativo previsto per l'elenco. Se prima di tutto
non è già un elenco del tipo corretto, verrà aggiornato in uno. Se uno dei due
prima di tutto or ultimo è null, l'altro viene restituito invariato.

OP * op_append_elem(I32 opttype, OP *primo, OP *ultimo)

op_append_list
Concatena gli elenchi di operazioni contenute direttamente all'interno di due operazioni di tipo elenco,
restituendo l'elenco combinato. prima di tutto e a ultimo sono le operazioni di tipo elenco da concatenare.
tipo ottuso specifica il codice operativo previsto per l'elenco. Se uno dei due prima di tutto or ultimo non è
già un elenco del tipo corretto, verrà aggiornato in uno. Se uno dei due prima di tutto
or ultimo è null, l'altro viene restituito invariato.

OP * op_append_list(I32 opttype, OP *primo, OP *ultimo)

OP_CLASS
Restituisce la classe dell'OP fornito: ovvero quale delle strutture *OP utilizza.
Per le operazioni principali questo attualmente ottiene le informazioni da PL_opargs, il che non lo fa
rispecchiare sempre accuratamente il tipo utilizzato. Per le operazioni personalizzate da cui viene restituito il tipo
la registrazione, e spetta al registro assicurarne l'accuratezza. Il
il valore restituito sarà una delle costanti OA_* da op.h.

U32 CLASSE_OP(OP *o)

op_contestualizzare
Applica un contesto sintattico a un albero operativo che rappresenta un'espressione. o è l'op
albero, e contesto deve essere "G_SCALAR", "G_ARRAY" o "G_VOID" per specificare il
contesto da applicare. Viene restituito l'albero operativo modificato.

OP * op_contextualize(OP *o, contesto I32)

op_convert_list
Converte o in un elenco op se non è già uno, quindi lo converte in
specificato Digitare, chiamando la sua funzione di controllo, allocando un obiettivo se ne ha bisogno,
e costanti di piegatura.

Un'operazione di tipo elenco viene solitamente costruita un bambino alla volta tramite "newLISTOP",
"op_prepend_elem" e "op_append_elem". Poi finalmente si passa a
"op_convert_list" per renderlo del tipo giusto.

OP * op_convert_list (tipo I32, flag I32, OP * o)

OP_DESC Restituisce una breve descrizione dell'OP fornito.

const carattere * OP_DESC(OP *o)

op_free Libera un op. Usalo solo quando un'operazione non è più collegata a nessun optree.

void op_free(OP *o)

op_linklist
Questa funzione è l'implementazione della macro "LINKLIST". Non dovrebbe essere
chiamato direttamente.

OP* op_linklist(OP *o)

op_lvalue
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Propaga il contesto lvalue ("modificabile") a un op e ai suoi figli. Digitare
rappresenta il tipo di contesto, approssimativamente in base al tipo di operazione che farebbe il
modificando, sebbene "local()" sia rappresentato da OP_NULL, perché non ha tipo op
di per sé (è segnalato da un flag su lvalue op).

Questa funzione rileva cose che non possono essere modificate, come "$x+1", e genera
errori per loro. Ad esempio, "$x+1 = 2" lo farebbe chiamare con un'op
di tipo OP_ADD e un argomento "tipo" di OP_SASSIGN.

Contrassegna anche le cose che devono comportarsi specialmente in un contesto lvalue, come
"$$x = 5" che potrebbe dover vivificare un riferimento in $x.

OP * op_lvalue(OP *o, tipo I32)

OP_NAME Restituisce il nome dell'OP fornito. Per le operazioni principali, questo cerca il nome da
tipo_op; per le operazioni personalizzate da op_ppaddr.

const carattere * OP_NAME(OP *o)

op_null Neutralizza un'operazione quando non è più necessaria, ma è ancora collegata ad altre
op.

void op_null(OP *o)

op_parent
Restituisce l'OP padre di o, se ha un padre. Restituisce NULL in caso contrario. Questo
la funzione è disponibile solo su perl compilati con "-DPERL_OP_PARENT".

OP* op_parent(OP *o)

op_prepend_elem
Anteponi un elemento all'elenco delle operazioni contenute direttamente all'interno di un'operazione di tipo elenco,
restituendo l'elenco allungato. prima di tutto è l'op da anteporre all'elenco, e ultimo
è l'op di tipo elenco. tipo ottuso specifica il codice operativo previsto per l'elenco. Se ultimo
non è già un elenco del tipo corretto, verrà aggiornato in uno. Se uno dei due
prima di tutto or ultimo è null, l'altro viene restituito invariato.

OP * op_prepend_elem(I32 optype, OP *primo, OP *ultimo)

op_scope
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Avvolge un albero operativo con alcune operazioni aggiuntive in modo che in fase di esecuzione un ambito dinamico
verrà creato. Le operazioni originali vengono eseguite nel nuovo ambito dinamico, quindi
a condizione che escano normalmente, l'ambito sarà svolto. Le operazioni aggiuntive
utilizzato per creare e svolgere l'ambito dinamico sarà normalmente un "invio"/"abbandono"
coppia, ma è possibile utilizzare invece un'operazione "ambito" se le operazioni sono abbastanza semplici da non farlo
necessitano della struttura dell'ambito dinamico completo.

OP * ambito_op(OP *o)

op_sibling_splice
Una funzione generale per modificare la struttura di una catena esistente di op_sibling
nodi. Per analogia con il livello perl giunzione() funzione, consente di eliminare
zero o più nodi sequenziali, sostituendoli con zero o più nodi differenti.
Esegue la necessaria pulizia op_first/op_last sul nodo padre e
manipolazione op_sibling sui bambini. L'ultimo nodo eliminato verrà contrassegnato come
come ultimo nodo aggiornando il campo op_sibling/op_sibparent o op_moresib as
appropriato.

Nota che op_next non viene manipolato e i nodi non vengono liberati; questo è il
responsabilità del chiamante. Inoltre, non creerà una nuova lista op per un vuoto
elenco ecc; utilizzare funzioni di livello superiore come op_append_elem() per quello.

parent è il nodo padre della catena di fratelli. Può essere passato come NULL se il
lo splicing non influisce sulla prima o sull'ultima operazione nella catena.

start è il nodo che precede il primo nodo da giuntare. Nodo(i) che lo segue
verrà eliminato e le operazioni verranno inserite dopo di esso. Se è NULL, il primo nodo
in poi viene cancellato e i nodi vengono inseriti all'inizio.

del_count è il numero di nodi da eliminare. Se zero, nessun nodo viene eliminato. Se -1
o maggiore o uguale al numero di bambini rimanenti, tutti i bambini rimanenti lo sono
cancellato.

insert è il primo di una catena di nodi da inserire al posto dei nodi. Se
NULL, nessun nodo è inserito.

Viene restituito il capo della catena di operazioni eliminate o NULL se non sono state eliminate operazioni.

Per esempio:

azione prima dopo i ritorni
------ ----- ------------

PP
giunzione(P, A, 2, XYZ) | | AVANTI CRISTO
ABCD AXYZD

PP
giunzione(P, NULL, 1, XY) | | UN
ABCD XYBCD

PP
giunzione(P, NULL, 3, NULL) | | ABC
ABCD D

PP
giunzione(P, B, 0, XY) | | NULLO
ABCD ABXYCD

Per la manipolazione diretta di livello inferiore di "op_sibparent" e "op_moresib", vedere
"OpMORESIB_set", "OpLASTSIB_set", "OpMAYBESIB_set".

OP* op_sibling_splice(OP *genitore, OP *inizio,
int del_count, OP* inserire)

OP_TYPE_IS
Restituisce true se l'OP specificato non è un puntatore NULL e se è del tipo specificato.

È disponibile anche la negazione di questa macro, "OP_TYPE_ISNT".
"OP_TYPE_IS_NN" e "OP_TYPE_ISNT_NN" che eliminano il controllo del puntatore NULL.

bool OP_TYPE_IS(OP *o, tipo Optype)

OP_TYPE_IS_OR_WAS
Restituisce true se l'OP specificato non è un puntatore NULL e se è del tipo specificato
o prima di essere sostituito da un OP di tipo OP_NULL.

È disponibile anche la negazione di questa macro, "OP_TYPE_ISNT_AND_WASNT".
"OP_TYPE_IS_OR_WAS_NN" e "OP_TYPE_ISNT_AND_WASNT_NN" che eliminano il NULL
controllo del puntatore.

bool OP_TYPE_IS_OR_WAS(OP *o, tipo Optype)

rv2cv_op_cv
Esamina un'operazione, che dovrebbe identificare una subroutine in fase di esecuzione, e
tenta di determinare in fase di compilazione quale subroutine identifica. Questo è
normalmente utilizzato durante la compilazione Perl per determinare se un prototipo può essere
applicato a una chiamata di funzione. cv è l'op in esame, normalmente un "rv2cv"
operazione. Viene restituito un puntatore alla subroutine identificata, se è possibile determinarla
staticamente e viene restituito un puntatore nullo se non è stato possibile determinarlo
staticamente.

Attualmente, la subroutine può essere identificata staticamente se il RV che il "rv2cv"
deve operare è fornito da apposito "gv" o "const" op. Un'operazione "gv" è
adatto se lo slot CV del GV è popolato. Un'operazione "const" è adatta se il
il valore costante deve essere un RV che punta a un CV. I dettagli di questo processo potrebbero cambiare
nelle versioni future di Perl. Se l'operazione "rv2cv" ha il flag "OPpENTERSUB_AMPER".
set allora non viene fatto nessun tentativo di identificare la subroutine staticamente: questo flag è
usato per sopprimere la magia in fase di compilazione su una chiamata di subroutine, costringendola a usarla
comportamento di runtime predefinito.

If bandiere ha il bit "RV2CVOPCV_MARK_EARLY" impostato, quindi la gestione di un GV
il riferimento è modificato. Se un GV è stato esaminato e il suo slot CV è risultato essere
vuoto, quindi l'operazione "gv" ha il flag "OPpEARLY_CV" impostato. Se l'operazione non lo è
ottimizzato via, e lo slot CV viene successivamente popolato con una subroutine avente a
prototipo, quella bandiera alla fine attiva l'avviso "chiamato troppo presto per controllare
prototipo".

If bandiere ha il bit "RV2CVOPCV_RETURN_NAME_GV" impostato, quindi invece di restituire a
puntatore alla subroutine restituisce un puntatore al GV che dà il massimo
nome appropriato per la subroutine in questo contesto. Normalmente questo è solo il
"CvGV" della subroutine, ma per una subroutine anonima ("CvANON") cioè
referenziato tramite un GV sarà il GV di riferimento. Il "GV*" risultante è
cast a "CV*" da restituire. Un puntatore nullo viene restituito come al solito se non c'è
subroutine staticamente determinabile.

CV * rv2cv_op_cv(OP *cvop, flag U32)

PACK e a disfare

lista di pacchetti
L'implementazione del motore pacchetto() funzione Perl.

void packlist(SV *cat, const char *pat,
const carattere *patend, SV **beglist,
SV **fine lista)

decomprimere la stringa
Il motore che implementa il scompattare() funzione Perl.

Usando il modello pat..patend, questa funzione decomprime la stringa s..strend in a
numero di SV mortali, che inserisce nello stack dell'argomento perl (@_) (quindi tu
dovrà emettere un "PUTBACK" prima e "SPAGAIN" dopo la chiamata a questo
funzione). Restituisce il numero di elementi spinti.

I puntatori strend e paend dovrebbero puntare al byte successivo all'ultimo
carattere di ogni stringa.

Sebbene questa funzione restituisca i suoi valori nello stack di argomenti perl, non lo fa
prendi qualsiasi parametro da quello stack (e quindi in particolare non è necessario farlo
un PUSHMARK prima di chiamarlo, a differenza ad esempio di "call_pv").

I32 unpackstring(const char *pat,
const char *patend, const char *s,
const char *strend, bandiere U32)

tampone Dati Strutture

CvPADLIST
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

I CV possono avere CvPADLIST(cv) impostato per puntare a una PADLIST. Questo è il CV
scratchpad, che memorizza variabili lessicali e codice operativo temporanei e per thread
valori.

A tal fine i "formati" sono una specie di CV; Anche eval""s lo sono (tranne che non lo sono
richiamabili a piacimento e vengono sempre gettati via dopo che l'esecuzione di eval"" è terminata).
I file richiesti sono semplicemente evals senza alcun ambito lessicale esterno.

Gli XSUB non hanno una CvPADLIST. dXSTARG recupera i valori da PL_curpad, ma è così
davvero il pad del chiamante (uno slot del quale è allocato da ogni entersub). Non
ottenere o impostare CvPADLIST se un CV è un XSUB (come determinato da "CvISXSUB()"), CvPADLIST
lo slot viene riutilizzato per uno scopo interno diverso negli XSUB.

La PADLIST ha un array C in cui sono memorizzati i pad.

La 0a voce della PADLIST è una PADNAMELIST che rappresenta i "nomi" o
piuttosto le "informazioni sul tipo statico" per i lessicali. I singoli elementi di a
PADNAMELIST sono PADNAME. I futuri refactoring potrebbero impedire a PADNAMELIST di
essendo memorizzato nell'array di PADLIST, quindi non fare affidamento su di esso. Vedi "PadlistNAMES".

La voce CvDEPTH'esima di una PADLIST è un PAD (un AV) che è lo stack frame in
quella profondità di ricorsione nel CV. Lo 0° slot di un frame AV è un AV che è
@_. Altre voci sono l'archiviazione per variabili e target operativi.

L'iterazione su PADNAMELIST esegue l'iterazione su tutti i possibili elementi del pad. Slot per pad
per i target (SVs_PADTMP) e i GV finiscono per avere &PL_padname_undef "nomi", mentre
gli slot per le costanti hanno &PL_padname_const "nomi" (vedi pad_alloc()). Quella
&PL_padname_undef e &PL_padname_const sono usati è un dettaglio di implementazione
soggetto a modifiche. Per testarli, usa "!PadnamePV(name)" e "PadnamePV(name)
&& !PadnameLEN(name)", rispettivamente.

Solo i miei/nostri slot variabili ottengono nomi validi. Il resto sono obiettivi operativi/GV/costanti
che sono stati allocati o risolti in fase di compilazione. Questi non hanno
nomi con cui possono essere cercati dal codice Perl in fase di esecuzione tramite eval"" the
come possono essere le mie/nostre variabili. Dal momento che non possono essere cercati per "nome" ma solo per
il loro indice allocato in fase di compilazione (che di solito è in PL_op->op_targ),
sprecare un nome SV per loro non ha senso.

I nomi dei pad in PADNAMELIST hanno il loro PV che contiene il nome della variabile.
I campi COP_SEQ_RANGE_LOW e _HIGH formano un intervallo (basso+1..alto compreso) di
cop_seq numeri per i quali il nome è valido. Durante la compilazione, questi campi possono
tieni premuto il valore speciale PERL_PADSEQ_INTRO per indicare le varie fasi:

COP_SEQ_RANGE_LOW _HIGH
------------------ -----
PERL_PADSEQ_INTRO 0 variabile non ancora introdotta:
{ mio ($ x
valid-seq# variabile PERL_PADSEQ_INTRO nell'ambito:
{ mio ($ x)
valida-seq# valida-seq# compilazione dell'ambito completata:
{ mio ($ x) }

Per i lessici digitati PadnameTYPE punta al tipo stash. Per i "nostri" lessicali,
PadnameOURSTASH punta allo stash del global associato (in modo che duplicate
possono essere rilevate le "nostre" dichiarazioni nello stesso pacco). PadnameGEN è a volte
utilizzato per memorizzare il numero di generazione durante la compilazione.

Se PadnameOUTER è impostato sul nome del pad, allora quello slot nel frame AV è a
REFCNT'ed riferimento a un lessico da "fuori". Tali voci sono a volte
denominato 'falso'. In questo caso, il nome non utilizza 'basso' e 'alto' per
memorizzare un intervallo cop_seq, poiché è nell'ambito di tutto. Invece negozi "alti".
alcuni flag contenenti informazioni sul lessico reale (è dichiarato in un anonimo, e
è in grado di essere istanziato più volte?) e per gli ANON falsi, "basso"
contiene l'indice all'interno del pad del genitore in cui è memorizzato il valore del lessicale, a
rendere la clonazione più veloce.

Se il 'nome' è '&' la voce corrispondente nel PAD è un CV che rappresenta a
possibile chiusura.

Si noti che i formati vengono trattati come sottotitoli anonimi e vengono clonati ogni volta che lo si scrive
chiamato (se necessario).

Il flag SVs_PADSTALE viene cancellato sui lessicali ogni volta che il mio() viene eseguito, e
impostato all'uscita dall'ambito. Ciò consente di visualizzare l'avviso "Variabile $ x non disponibile".
generato in valori, come

{ mio $ x = 1; sub f { valore '$x'} } f();

Per state vars, SVs_PADSTALE è sovraccarico per indicare 'non ancora inizializzato', ma questo
lo stato interno viene memorizzato in una voce pad separata.

ELENCOPAD * CvELENCOPAD(CV *cv)

PadARRAY
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

L'array C delle voci pad.

SV ** PadARRAY (rilievo PAD)

PadlistARRAY
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

L'array C di una padlist, contenente i pad. Indicizzalo solo con numeri >=
1, poiché non è garantito che la voce 0 rimanga utilizzabile.

PAD ** PadlistARRAY(padlist PADLIST)

PadlistMAX
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

L'indice dell'ultimo spazio allocato nella padlist. Si noti che l'ultimo pad può
essere in uno slot precedente. Qualsiasi voce successiva sarà NULL in quel caso.

SSize_t PadlistMAX(PADLIST padlist)

PadlistNAMES
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

I nomi associati alle voci del pad.

PADNAMELIST * PadlistNAMES(PADLIST padlist)

PadlistNAMESARRAY
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

La matrice C dei nomi dei pad.

PADNAME ** PadlistNAMESARRAY(PADLIST padlist)

PadlistNAMESMAX
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

L'indice del cognome del pad.

SSize_t PadlistNAMESMAX(PADLIST padlist)

PadlistREFCNT
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Il conteggio di riferimento della padlist. Attualmente questo è sempre 1.

U32 PadlistREFCNT(PADLIST padlist)

PadMAX NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

L'indice dell'ultima voce di pad.

SSize_t PadMAX (pad PAD)

Nome padLEN
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

La lunghezza del nome.

STRLEN PadnameLEN(PADNAME pn)

ElencopadnameARRAY
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

La matrice C dei nomi dei pad.

PADNAME ** PadnamelistARRAY(PADNAMELIST pnl)

PadnamelistMAX
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

L'indice del cognome del pad.

SSize_t PadnamelistMAX(PADNAMELIST pnl)

ElenconomipadREFCNT
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Il conteggio dei riferimenti dell'elenco dei nomi dei pad.

SSize_t PadnamelistREFCNT(PADNAMELIST pnl)

ElencopadnameREFCNT_dec
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Riduce il conteggio dei riferimenti dell'elenco dei nomi dei pad.

void PadnamelistREFCNT_dec(PADNAMELIST pnl)

PadnamePV
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Il nome memorizzato nella struttura del nome del pad. Questo restituisce NULL per uno slot di destinazione.

char * PadnamePV(PADNAME pn)

NomepadREFCNT
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Il conteggio dei riferimenti del nome del pad.

SSize_t PadnameREFCNT(PADNAME pn)

NomepadREFCNT_dec
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Riduce il conteggio dei riferimenti del nome del pad.

void PadnameREFCNT_dec(PADNAME pn)

PadnameSV
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Restituisce il nome del pad come SV mortale.

SV * PadnameSV(PADNAME pn)

Nome padUTF8
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Se PadnamePV è in UTF8. Attualmente, questo è sempre vero.

bool NomePadUTF8(NOMEPAD pn)

pad_add_name_pvs
Esattamente come "pad_add_name_pvn", ma accetta una stringa letterale invece di a
coppia stringa/lunghezza.

PADOFFSET pad_add_name_pvs(const char *name, flag U32,
HV *dattiloscritto, HV *dattaceo)

pad_findmy_pvs
Esattamente come "pad_findmy_pvn", ma accetta una stringa letterale invece di a
coppia stringa/lunghezza.

PADOFFSET pad_findmy_pvs(const char *name, flag U32)

pad_new Crea una nuova padlist, aggiornando le variabili globali per la compilazione in corso
padlist per puntare alla nuova padlist. I seguenti flag possono essere combinati in OR:

padnew_CLONE questo pad è per un CV clonato
padnew_SAVE salva i vecchi globali nello stack di salvataggio
padnew_SAVESUB salva anche cose extra per l'inizio del sub

PADLIST * pad_new(int flags)

PL_comppad
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Durante la compilazione, punta all'array contenente i valori che fanno parte del pad
per il codice in fase di compilazione. (In fase di esecuzione un CV può avere molti di questi valori
matrici; in fase di compilazione ne viene costruito solo uno.) In fase di esecuzione, questo punta al
array contenente i valori attualmente rilevanti per il pad per l'attuale
codice in esecuzione.

PL_nome_comppad
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Durante la compilazione, punta all'array contenente i nomi della parte del pad
per il codice in fase di compilazione.

PL_curpad
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Punta direttamente al corpo dell'array "PL_comppad". (Cioè, questo è
"PAD_ARRAY(PL_comppad)".)

Per-interprete Variabili

PL_modglobale
"PL_modglobal" è un interprete HV globale di uso generale per l'uso da parte delle estensioni
che devono conservare le informazioni in base all'interprete. In un pizzico, può anche
essere utilizzato come tabella dei simboli per le estensioni per condividere i dati tra loro. È un
buona idea usare chiavi precedute dal nome del pacchetto dell'estensione che possiede il file
dati.

HV* PL_modglobale

PL_na Una variabile di convenienza che viene generalmente utilizzata con "SvPV" quando non interessa
circa la lunghezza della corda. Di solito è più efficiente dichiarare a
variabile locale e usa quella invece o per usare la macro "SvPV_nolen".

STRLEN PL_na

PL_opfreehook
Quando non è "NULL", la funzione puntata da questa variabile verrà chiamata ogni volta che an
OP viene liberato con l'OP corrispondente come argomento. Ciò consente alle estensioni di
liberare qualsiasi attributo aggiuntivo che hanno collegato localmente a un OP. È anche assicurato
per sparare prima per l'OP principale e poi per i suoi figli.

Quando si sostituisce questa variabile, è considerata una buona pratica memorizzare il file
gancio eventualmente installato in precedenza e che lo richiami all'interno del tuo.

Perl_ophook_t PL_opfreehook

PL_peep
Puntatore all'ottimizzatore spioncino per subroutine. Questa è una funzione che ottiene
chiamato al termine della compilazione di una subroutine Perl (o equivalentemente indipendente
pezzo di codice Perl) per eseguire correzioni di alcune operazioni e per eseguire su piccola scala
ottimizzazioni. La funzione viene chiamata una volta per ogni subroutine compilata,
e viene passato, come unico parametro, un puntatore all'op che è il punto di ingresso
il sottoprogramma. Modifica l'op tree in atto.

L'ottimizzatore spioncino non dovrebbe mai essere completamente sostituito. Piuttosto, aggiungi codice a
avvolgendo l'ottimizzatore esistente. Il modo di base per farlo può essere visto in
"Compile pass 3: ottimizzazione dello spioncino" in perlguts. Se il nuovo codice lo desidera
operare sulle operazioni in tutta la struttura della subroutine, piuttosto che solo nella parte superiore
livello, è probabile che sia più conveniente avvolgere l'hook "PL_rpeepp".

peep_tPL_peepp

PL_rpeepp
Puntatore all'ottimizzatore ricorsivo dello spioncino. Questa è una funzione che viene chiamata
al termine della compilazione di una subroutine Perl (o pezzo equivalentemente indipendente
del codice Perl) per eseguire correzioni di alcune operazioni e per eseguire su piccola scala
ottimizzazioni. La funzione viene chiamata una volta per ogni catena di operazioni collegate
i loro campi "op_next"; è chiamato ricorsivamente per gestire ciascuna catena laterale. è
passato, come unico parametro, un puntatore all'op che si trova in testa alla catena.
Modifica l'op tree in atto.

L'ottimizzatore spioncino non dovrebbe mai essere completamente sostituito. Piuttosto, aggiungi codice a
avvolgendo l'ottimizzatore esistente. Il modo di base per farlo può essere visto in
"Compile pass 3: ottimizzazione dello spioncino" in perlguts. Se il nuovo codice lo desidera
operare solo su operazioni al livello più alto di una subroutine, piuttosto che in tutto il
struttura, è probabile che sia più conveniente avvolgere l'hook "PL_peepp".

peep_tPL_rpeepp

PL_sv_no
Questo è il "falso" SV. Vedere "PL_sv_yes". Fare sempre riferimento a questo come &PL_sv_no.

SV PL_sv_no

PL_sv_undef
Questo è il "undef" SV. Fare sempre riferimento a questo come &PL_sv_undef.

SVPL_sv_undef

PL_sv_sì
Questo è il "vero" SV. Vedere "PL_sv_no". Fare sempre riferimento a questo come &PL_sv_yes.

SV PL_sv_sì

REGEXP funzioni

SvRX Macro di convenienza per ottenere il REGEXP da un SV. Questo è approssimativamente equivalente
al seguente frammento:

se (SvMAGICO(sv))
mg_get(sv);
se (SvROK(sv))
sv = MUTABLE_SV(SvRV(sv));
se (SvTYPE(sv) == SVt_REGEXP)
ritorno (REGEXP*) sv;

NULL verrà restituito se non viene trovato un REGEXP*.

REGEXP * SvRX(SV *sv)

SvRXOK Restituisce un booleano che indica se l'SV (o quello a cui fa riferimento) è a
REGESP.

Se vuoi fare qualcosa con REGEXP* in seguito, usa invece SvRX e controlla
NULLO.

bool SvRXOK(SV*sv)

pila Manipolazione Macro

dMARK Dichiara una variabile indicatore di stack, "mark", per XSUB. Vedere "MARK" e
"dORIGMARK".

dMarco;

dORIGMARK
Salva lo stack mark originale per XSUB. Vedere "SEGNO D'ORIGINE".

dORIGMARK;

dSP Dichiara una copia locale del puntatore dello stack di perl per XSUB, disponibile tramite "SP"
macro. Vedere "SP".

dSP;

ESTENDI Utilizzato per estendere lo stack di argomenti per i valori di ritorno di un XSUB. Una volta utilizzato,
garantisce che ci sia spazio per almeno "nitem" da inserire nello stack.

void EXTEND(SP, SSize_t articoli)

MARK Variabile indicatore di stack per XSUB. Vedi "dMARK".

mPUSHi Inserisce un numero intero nello stack. La pila deve avere spazio per questo elemento. Fa
non utilizzare "TARG". Vedere anche "PUSHi", "mXPUSHi" e "XPUSHi".

vuoto mPUSHi(IV iv)

mPUSHn Spingere un doppio sullo stack. La pila deve avere spazio per questo elemento. Fa
non utilizzare "TARG". Vedere anche "PUSHn", "mXPUSHn" e "XPUSHn".

vuoto mPUSHn(NV nv)

mPUSHp Spingere una stringa nello stack. La pila deve avere spazio per questo elemento. Il
"len" indica la lunghezza della stringa. Non usa "TARG". Vedi anche "PUSHp",
"mXPUSHp" e "XPUSHp".

void mPUSHp(char* str, STRLEN len)

mPUSHs Spinge un SV sullo stack e mortalizza l'SV. La pila deve avere spazio per
questo elemento. Non usa "TARG". Vedi anche "PUSH" e "mXPUSH".

void mPUSH (SV* sv)

mPUSHu Inserisce un numero intero senza segno nello stack. La pila deve avere spazio per questo
elemento. Non usa "TARG". Vedi anche "PUSHu", "mXPUSHu" e "XPUSHu".

vuoto mPUSHu (UV uv)

mXPUSHi Spingere un numero intero nello stack, estendendolo se necessario. Non usa
"TARG". Vedere anche "XPUSHi", "mPUSHi" e "PUSHi".

vuoto mXPUSHi(IV iv)

mXPUSHn Spingere un doppio sulla pila, estendendo la pila se necessario. Non usa
"TARG". Vedere anche "XPUSHn", "mPUSHn" e "PUSHn".

vuoto mXPUSHn(NV nv)

mXPUSHp Spingere una stringa sullo stack, estendendolo se necessario. Il "len"
indica la lunghezza della stringa. Non usa "TARG". Vedi anche "XPUSHp",
"mPUSHp" e "PUSHp".

void mXPUSHp(char* str, STRLEN len)

mXPUSH Spinge un SV sullo stack, estendendolo se necessario e mortalizza l'SV.
Non usa "TARG". Vedere anche "XPUSH" e "mPUSH".

void mXPUSH (SV* sv)

mXPUSHu Inserisce un numero intero senza segno nello stack, estendendolo se necessario. Fa
non utilizzare "TARG". Vedi anche "XPUSHu", "mPUSHu" e "PUSHu".

vuoto mXPUSHu (UV uv)

ORIGMARK
Il segno di stack originale per XSUB. Vedere "dORIGMARK".

POPi Estrae un intero dallo stack.

IV POPi

POPl Esce a lungo dallo stack.

lungo POPl

POPn Estrae un doppio dallo stack.

NV POP n

POPp Estrae una stringa dallo stack.

car* POPp

POPpbytex
Estrae dallo stack una stringa che deve essere composta da byte, ad esempio caratteri < 256.

carattere* POPpbytex

POPpx Estrae una stringa dallo stack. Identico a POPp. Ci sono due nomi per
ragioni storiche.

carattere* POPpx

POP Estrae un SV dallo stack.

SV* POP

PUSHi Spinge un numero intero nello stack. La pila deve avere spazio per questo elemento.
Gestisce la magia "set". Utilizza "TARG", quindi dovrebbe essere chiamato "dTARGET" o "dXSTARG".
dichiararlo. Non chiamare più macro orientate a "TARG" da cui restituire elenchi
XSUB's - vedi invece "mPUSHi". Vedere anche "XPUSHi" e "mXPUSHi".

vuoto PUSHi(IV iv)

PUSHMARK
Parentesi di apertura per argomenti su un callback. Vedi "PUTBACK" e perlcall.

vuoto PUSHMARK(SP)

PUSHmortale
Spingi un nuovo SV mortale sulla pila. La pila deve avere spazio per questo elemento.
Non usa "TARG". Vedi anche "PUSH", "XPUSHmortal" e "XPUSH".

vuoto PUSHmortale()

PUSHn Spingere un doppio sullo stack. La pila deve avere spazio per questo elemento. Maniglie
Magia "impostata". Usa "TARG", quindi "dTARGET" o "dXSTARG" dovrebbero essere chiamati per dichiarare
esso. Non chiamare più macro orientate a "TARG" per restituire elenchi da XSUB - vedi
invece "mPUSHn". Vedere anche "XPUSHn" e "mXPUSHn".

vuoto PUSHn(NV nv)

PUSHp Spingere una stringa sulla pila. La pila deve avere spazio per questo elemento. Il
"len" indica la lunghezza della stringa. Gestisce la magia "set". Usa "TARG", quindi
"dTARGET" o "dXSTARG" dovrebbero essere chiamati per dichiararlo. Non chiamare più
Macro orientate a "TARG" per restituire elenchi da XSUB - vedere invece "mPUSHp". Vedere
anche "XPUSHp" e "mXPUSHp".

void PUSHp(char* str, STRLEN len)

PUSH Spingono un SV nello stack. La pila deve avere spazio per questo elemento. Non
gestire la magia 'set'. Non usa "TARG". Vedi anche "PUSHmortal", "XPUSH" e
"XPUSHmortale".

void PUSH (SV* sv)

PUSHu Spinge un numero intero senza segno nello stack. La pila deve avere spazio per questo
elemento. Gestisce la magia "set". Utilizza "TARG", quindi dovrebbe essere "dTARGET" o "dXSTARG".
chiamato a dichiararlo. Non chiamare più macro orientate a "TARG" per restituire elenchi
da XSUB - vedi invece "mPUSHu". Vedi anche "XPUSHu" e "mXPUSHu".

vuoto PUSHu (UV uv)

PUTBACK Parentesi di chiusura per argomenti XSUB. Questo di solito è gestito da "xsubpp". Vedere
"PUSHMARK" e perlcall per altri usi.

RIMETTERE A POSTO;

Puntatore dello stack SP. Questo di solito è gestito da "xsubpp". Vedi "dSP" e "SPAGAIN".

SPAGAIN Recupera il puntatore dello stack. Usato dopo una richiamata. Vedi perlcall.

SPAGNA;

XPUSHi Spingere un numero intero nello stack, estendendolo se necessario. Maniglie 'set'
Magia. Usa "TARG", quindi "dTARGET" o "dXSTARG" dovrebbero essere chiamati per dichiararlo. Fare
non chiamare più macro orientate a "TARG" per restituire elenchi da XSUB - vedi
"mXPUSHi" invece. Vedi anche "PUSHi" e "mPUSHi".

vuoto XPUSHi(IV iv)

XPUSHmortale
Spingi un nuovo SV mortale sulla pila, estendendo la pila se necessario. Non
usa "TARG". Vedi anche "XPUSH", "PUSHmortal" e "PUSH".

vuoto XPUSHmortale()

XPUSHn Spingere un doppio sulla pila, estendendo la pila se necessario. Maniglie 'set'
Magia. Usa "TARG", quindi "dTARGET" o "dXSTARG" dovrebbero essere chiamati per dichiararlo. Fare
non chiamare più macro orientate a "TARG" per restituire elenchi da XSUB - vedi
"mXPUSHn" invece. Vedi anche "PUSHn" e "mPUSHn".

vuoto XPUSHn(NV nv)

XPUSHp Spingere una stringa sulla pila, estendendo la pila se necessario. Il "len"
indica la lunghezza della stringa. Gestisce la magia "set". Usa "TARG", quindi
"dTARGET" o "dXSTARG" dovrebbero essere chiamati per dichiararlo. Non chiamare più
Macro orientate a "TARG" per restituire elenchi da XSUB - vedere invece "mXPUSHp". Vedere
anche "PUSHp" e "mPUSHp".

void XPUSHp(char* str, STRLEN len)

XPUSH Spingono un SV nello stack, estendendolo se necessario. Non gestisce
Magia "impostata". Non usa "TARG". Vedi anche "XPUSHmortal", "PUSH" e
"PUSHmortal".

XPUSH nulli (SV* sv)

XPUSHu Spingere un numero intero senza segno nello stack, estendendolo se necessario.
Gestisce la magia "set". Utilizza "TARG", quindi dovrebbe essere chiamato "dTARGET" o "dXSTARG".
dichiararlo. Non chiamare più macro orientate a "TARG" da cui restituire elenchi
XSUB's - vedi invece "mXPUSHu". Vedi anche "PUSHu" e "mPUSHu".

vuoto XPUSHu (UV uv)

XSRITORNA
Ritorno da XSUB, indicando il numero di articoli in pila. Questo è di solito
gestito da "xsubpp".

void XSRETURN(int nitems)

XSRETURN_EMPTY
Restituisce immediatamente un elenco vuoto da un XSUB.

XSRETURN_VUOTO;

XSRETURN_IV
Restituisce immediatamente un numero intero da un XSUB. Utilizza "XST_mIV".

vuoto XSRETURN_IV(IV iv)

XSRETURN_NO
Restituisci immediatamente &PL_sv_no da un XSUB. Utilizza "XST_mNO".

XSRETURN_NO;

XSRETURN_NV
Restituisci immediatamente un doppio da un XSUB. Utilizza "XST_mNV".

void XSRETURN_NV(NV nv)

XSRETURN_PV
Restituisci immediatamente una copia di una stringa da un XSUB. Utilizza "XST_mPV".

void XSRETURN_PV(char* str)

XSRETURN_UNDEF
Restituisci immediatamente &PL_sv_undef da un XSUB. Utilizza "XST_mUNDEF".

XSRETURN_UNDEF;

XSRETURN_UV
Restituisce immediatamente un numero intero da un XSUB. Utilizza "XST_mUV".

void XSRETURN_UV(IV uv)

XSRETURN_YES
Restituisci immediatamente &PL_sv_yes da un XSUB. Utilizza "XST_mYES".

XSRETURN_YES;

XST_mIV Posiziona un numero intero nella posizione specificata "pos" nello stack. Il valore è
immagazzinato in una nuova SV mortale.

void XST_mIV(int pos, IV iv)

XST_mNO Posizionare &PL_sv_no nella posizione specificata "pos" nello stack.

void XST_mNO(int pos)

XST_mNV Posiziona un double nella posizione specificata "pos" sullo stack. Il valore è
immagazzinato in una nuova SV mortale.

void XST_mNV(int pos, NV nv)

XST_mPV Posiziona una copia di una stringa nella posizione specificata "pos" nello stack. Il
il valore viene memorizzato in un nuovo SV mortale.

void XST_mPV(int pos, char* str)

XST_mUNDEF
Posiziona &PL_sv_undef nella posizione specificata "pos" nello stack.

void XST_mUNDEF(int pos)

XST_mSI
Posiziona &PL_sv_yes nella posizione specificata "pos" nello stack.

void XST_mYES(int pos)

SV Bandiere

svtype Un enum di flag per i tipi Perl. Questi si trovano nel file sv.h nel "tipo sv"
enum. Testa questi flag con la macro "SvTYPE".

I tipi sono:

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_PVC
SVt_PVFM
SVT_PVIO

Questi sono più facilmente spiegabili dal basso verso l'alto.

SVt_PVIO è per oggetti I/O, SVt_PVFM per formati, SVt_PVCV per subroutine,
SVt_PVHV per gli hash e SVt_PVAV per gli array.

Tutti gli altri sono tipi scalari, cioè cose che possono essere associate a un "$"
variabile. Per questi, i tipi interni sono per lo più ortogonali ai tipi in
Linguaggio Perl.

Quindi, controllare "SvTYPE(sv) < SVt_PVAV" è il modo migliore per vedere se qualcosa
è uno scalare.

SVt_PVGV rappresenta un typeglob. Se !SvFAKE(sv), allora è un vero, incoercibile
typeglob. Se SvFAKE(sv), allora è uno scalare a cui è stato assegnato un typeglob
assegnato. Assegnarlo nuovamente impedirà che sia un typeglob. SVt_PVLV
rappresenta uno scalare che delega a un altro scalare dietro le quinte. è
utilizzato, ad esempio, per il valore di ritorno di "substr" e per hash e elementi di array legati.
Può contenere qualsiasi valore scalare, incluso un typeglob. SVt_REGEXP è per regolare
espressioni. SVt_INVLIST è solo per uso interno del core Perl.

SVt_PVMG rappresenta uno scalare "normale" (non un typeglob, un'espressione regolare o
delegare). Poiché la maggior parte degli scalari non necessita di tutti i campi interni di un PVMG, noi
risparmiare memoria allocando strutture più piccole quando possibile. Tutti gli altri tipi lo sono
solo forme più semplici di SVt_PVMG, con meno campi interni.
SVt_NULL può contenere solo indef. SVt_IV può contenere undef, un intero o un riferimento.
(SVt_RV è un alias per SVt_IV, che esiste per la compatibilità con le versioni precedenti.) SVt_NV
può contenere qualcuno di quelli o un doppio. SVt_PV può contenere solo undef o una stringa.
SVt_PVIV è un superset di SVt_PV e SVt_IV. SVt_PVNV è simile. SVt_PVMG può
tenere tutto ciò che SVt_PVNV può contenere, ma può, ma non deve, essere benedetto o
magico.

SVt_INVLIST
Digitare flag per scalari. Vedi "tipo sv".

SVt_IV Tipo di flag per scalari. Vedi "tipo sv".

SVt_NULL
Digitare flag per scalari. Vedi "tipo sv".

SVt_NV Tipo di flag per scalari. Vedi "tipo sv".

SVt_PV Tipo di flag per scalari. Vedi "tipo sv".

SVt_PVAV
Digitare flag per gli array. Vedi "tipo sv".

SVt_PVC
Digitare flag per le subroutine. Vedi "tipo sv".

SVt_PVFM
Digitare flag per i formati. Vedi "tipo sv".

SVt_PVGV
Digitare flag per typeglob. Vedi "tipo sv".

SVt_PVHV
Digita flag per gli hash. Vedi "tipo sv".

SVT_PVIO
Digitare il flag per gli oggetti I/O. Vedi "tipo sv".

SVT_PVIV
Digitare flag per scalari. Vedi "tipo sv".

SVt_PVLV
Digitare flag per scalari. Vedi "tipo sv".

SVT_PVMG
Digitare flag per scalari. Vedi "tipo sv".

SVt_PVNV
Digitare flag per scalari. Vedi "tipo sv".

SVt_REGEXP
Digitare flag per le espressioni regolari. Vedi "tipo sv".

SV Manipolazione funzioni

boolSV Restituisce un SV vero se "b" è un valore vero o un valore SV falso se "b" è 0.

Vedi anche "PL_sv_yes" e "PL_sv_no".

SV * boolSV(bool b)

croak_xs_usage
Una variante specializzata di "croak()" per emettere il messaggio di utilizzo per xsubs

croak_xs_usage(cv, "eee_yow");

elabora il nome del pacchetto e il nome della subroutine da "cv", quindi chiama
"gracchiare()". Quindi se "cv" è &ouch::awk, chiamerebbe "gracchiare" come:

Perl_croak(aTHX_ "Uso: %"SVf"::%"SVf"(%s)", "ahi" "awk",
"eee_yow");

void croak_xs_usage(const CV *const cv,
const char *const parametri)

get_sv Restituisce l'SV dello scalare Perl specificato. I "flags" vengono passati a "gv_fetchpv".
Se "GV_ADD" è impostato e la variabile Perl non esiste, verrà creata.
Se "flags" è zero e la variabile non esiste, viene restituito NULL.

NOTA: la forma perl_ di questa funzione è deprecata.

SV* get_sv(const char *name, flag I32)

nuovoRV_inc
Crea un wrapper RV per un SV. Il conteggio dei riferimenti per l'SV originale è
incrementato.

SV* nuovoRV_inc(SV* sv)

nuovoSVpadname
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Crea un nuovo SV contenente il nome del pad.

SV* nuovoSVnomepad(NOMEPAD *pn)

nuovoSVpvn_utf8
Crea un nuovo SV e copia una stringa (che può contenere caratteri "NUL" ("\0"))
dentro. Se utf8 è vero, chiama "SvUTF8_on" sul nuovo SV. Implementato come a
wrapper intorno a "newSVpvn_flags".

SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len,
U32utf8)

SvCUR Restituisce la lunghezza della stringa che si trova nell'SV. Vedere "SvLEN".

STRLEN SvCUR(SV*sv)

SvCUR_set
Imposta la lunghezza corrente della stringa che si trova nell'SV. Vedere "SvCUR" e
"SvIV_set".

void SvCUR_set(SV* sv, STRLEN len)

SvEND Restituisce un puntatore al punto subito dopo l'ultimo carattere nella stringa che è
in SV, dove di solito c'è un carattere "NUL" finale (anche se Perl
gli scalari non lo richiedono rigorosamente). Vedere "SvCUR". Accedi al personaggio come
*(SvEND(sv)).

Avvertenza: se "SvCUR" è uguale a "SvLEN", "SvEND" punta a non allocato
memoria.

char* SvEND(SV* sv)

SvGAMAGIC
Restituisce vero se l'SV ha ricevuto magia o sovraccarico. Se uno dei due è vero, allora il
scalare è un dato attivo e ha il potenziale per restituire un nuovo valore ogni volta
si accede. Quindi devi stare attento a leggerlo solo una volta per utente logico
operazione e lavorare con quel valore restituito. Se nessuno dei due è vero, allora lo scalare
il valore non può cambiare a meno che non venga scritto.

U32 SvGAMAGIC(SV*sv)

SvGROW Espande il buffer dei caratteri nell'SV in modo che abbia spazio per l'indicato
numero di byte (ricordarsi di riservare spazio per un carattere "NUL" finale aggiuntivo).
Chiama "sv_grow" per eseguire l'espansione, se necessario. Restituisce un puntatore a
buffer di caratteri. SV deve essere di tipo >= SVt_PV. Un'alternativa è chiamare
"sv_grow" se non sei sicuro del tipo di SV.

char * SvGROW(SV* sv, STRLEN len)

SvIOK Restituisce un valore U32 che indica se SV contiene un numero intero.

U32 SvIOK(SV*sv)

SvIOKp Restituisce un valore U32 che indica se l'SV contiene un numero intero. Controlla il
un bagno ambientazione. Utilizzare invece "SvIOK".

U32 SvIOKp(SV*sv)

SvIOK_notUV
Restituisce un valore booleano che indica se SV contiene un intero con segno.

bool SvIOK_notUV(SV*sv)

SvIOK_off
Disattiva lo stato IV di un SV.

void SvIOK_off(SV*sv)

SvIOK_on
Dice a un SV che è un numero intero.

void SvIOK_on(SV*sv)

Solo SvIOK
Dice a un SV che è un numero intero e disabilita tutti gli altri bit OK.

void SvIOK_only(SV* sv)

SvIOK_only_UV
Dice a un SV che è un intero senza segno e disabilita tutti gli altri bit OK.

void SvIOK_only_UV(SV*sv)

SvIOK_UV
Restituisce un valore booleano che indica se SV contiene un numero intero che deve essere
interpretato come non firmato. Un numero intero non negativo il cui valore è compreso nell'intervallo
di un IV e un UV possono essere contrassegnati come SvUOK o SVIOK.

bool SvIOK_UV(SV*sv)

SvIsCOW Restituisce un valore U32 che indica se l'SV è Copy-On-Write (o hash condiviso
scalari chiave o scalari completi Copy On Write se 5.9.0 è configurato per COW).

U32 SvISCOW(SV* sv)

SvIsCOW_shared_hash
Restituisce un valore booleano che indica se SV è una chiave hash condivisa Copy-On-Write
scalare.

bool SvIsCOW_shared_hash(SV*sv)

SvIV Costringe l'SV specificato a un numero intero e lo restituisce. Vedere "SvIVx" per una versione
che garantisce di valutare sv una sola volta.

EVSvIV(SV*sv)

SvIVX Restituisce il valore grezzo nello slot IV dell'SV, senza controlli o conversioni. Solo
usa quando sei sicuro che SvIOK sia vero. Vedi anche "SvIV()".

IVSvIVX(SV*sv)

SvIVx Forza l'SV specificato a un numero intero e lo restituisce. Garanzie da valutare "sv"
solo una volta. Usalo solo se "sv" è un'espressione con effetti collaterali, altrimenti
utilizzare il più efficiente "SvIV".

EV SvIVx(SV*sv)

SvIV_nomg
Come "SvIV" ma non elabora la magia.

IV SvIV_nomg(SV*sv)

SvIV_set
Impostare il valore del puntatore IV in sv su val. È possibile eseguire lo stesso
funzione di questa macro con assegnazione lvalue a "SvIVX". Con i futuri Perl,
tuttavia, sarà più efficiente usare "SvIV_set" invece di lvalue
assegnazione a "SvIVX".

void SvIV_set(SV* sv, IV val)

SvLEN Restituisce la dimensione del buffer di stringa nell'SV, esclusa qualsiasi parte
attribuibile a "SvOOK". Vedere "SvCUR".

STRLEN SvLEN(SV* sv)

SvLEN_set
Imposta la lunghezza effettiva della stringa che si trova nell'SV. Vedere "SvIV_set".

void SvLEN_set(SV* sv, STRLEN len)

SvMAGIC_set
Imposta il valore del puntatore MAGIC in sv su val. Vedere "SvIV_set".

void SvMAGIC_set(SV* sv, MAGIC* val)

SvNIOK Restituisce un valore U32 che indica se l'SV contiene un numero, un intero o
Doppio.

U32 SvNIOK(SV*sv)

SvNIOKp Restituisce un valore U32 che indica se l'SV contiene un numero, un intero o
Doppio. Controlla il un bagno ambientazione. Usa invece "SvNIOK".

U32 SvNIOKp(SV*sv)

SvNIOK_off
Disattiva lo stato NV/IV di un SV.

void SvNIOK_off(SV*sv)

SvNOK Restituisce un valore U32 che indica se l'SV contiene un double.

U32 SvNOK(SV*sv)

SvNOKp Restituisce un valore U32 che indica se l'SV contiene un double. Controlla il
un bagno ambientazione. Usa invece "SvNOK".

U32 SvNOKp(SV*sv)

SvNOK_off
Disattiva lo stato NV di un SV.

void SvNOK_off(SV*sv)

SvNOK_on
Dice a un SV che è un doppio.

void SvNOK_on(SV*sv)

Solo SvNOK
Dice a un SV che è un doppio e disabilita tutti gli altri bit OK.

void SvNOK_only(SV* sv)

SvNV Forza l'SV dato al doppio e lo restituisce. Vedere "SvNVx" per una versione che
garanzie di valutare sv una sola volta.

NVSvNV(SV*sv)

SvNVX Restituisce il valore grezzo nello slot NV dell'SV, senza controlli o conversioni. Solo
usa quando sei sicuro che SvNOK sia vero. Vedi anche "SvNV()".

NVSvNVX(SV*sv)

SvNVx Forza l'SV dato a un doppio e lo restituisce. Garanzie da valutare solo "sv".
una volta. Usalo solo se "sv" è un'espressione con effetti collaterali, altrimenti usa il
"SvNV" più efficiente.

NVSvNVx(SV*sv)

SvNV_nomg
Come "SvNV" ma non elabora la magia.

NV SvNV_nomg(SV*sv)

SvNV_set
Impostare il valore del puntatore NV in sv su val. Vedere "SvIV_set".

void SvNV_set(SV* sv, NV val)

SvOK Restituisce un valore U32 che indica se il valore è definito. Questo è solo
significativo per scalari.

U32 SvOK(SV*sv)

SvOOK Restituisce un U32 che indica se il puntatore al buffer di stringa è spostato. Questo
hack viene utilizzato internamente per velocizzare la rimozione dei personaggi dall'inizio di a
SvPV. Quando SvOOK è true, l'inizio del buffer di stringa allocato è
in realtà byte "SvOOK_offset()" prima di SvPVX. Questo offset veniva memorizzato
SvIVX, ma ora è memorizzato nella parte di ricambio del buffer.

U32 SvOOK(SV*sv)

SvOOK_offset
Legge dentro len l'offset da SvPVX torna al vero inizio dell'allocato
buffer, che sarà diverso da zero se è stato utilizzato "sv_chop" per rimuovere in modo efficiente
caratteri dall'inizio del buffer. Implementato come macro, che prende il file
indirizzo di len, che deve essere di tipo "STRLEN". Valuta sv più di una volta.
Set len a 0 se "SvOOK(sv)" è falso.

void SvOOK_offset(NN SV*sv, STRLEN len)

SvPOK Restituisce un valore U32 che indica se l'SV contiene una stringa di caratteri.

U32 SvPOK(SV* sv)

SvPOKp Restituisce un valore U32 che indica se l'SV contiene una stringa di caratteri. Controlli
, il un bagno ambientazione. Usa invece "SvPOK".

U32 SvPOKp(SV*sv)

SvPOK_off
Disattiva lo stato PV di un SV.

void SvPOK_off(SV*sv)

SvPOK_on
Dice a un SV che è una stringa.

void SvPOK_on(SV*sv)

Solo SvPOK
Dice a un SV che si tratta di una stringa e disabilita tutti gli altri bit OK. Si girerà anche
fuori dallo stato UTF-8.

void SvPOK_only(SV* sv)

SvPOK_only_UTF8
Dice a un SV che è una stringa e disabilita tutti gli altri bit OK e lascia il file
Lo stato UTF-8 così com'era.

void SvPOK_only_UTF8(SV*sv)

SvPV Restituisce un puntatore alla stringa nell'SV o una forma stringata dell'SV se il
SV non contiene una stringa. L'SV può memorizzare nella cache la versione stringata diventando
"SvPOK". Gestisce la magia "prendi". La variabile "len" verrà impostata sulla lunghezza di
la stringa (questa è una macro, quindi non usare &len). Vedi anche "SvPVx" per una versione
che garantisce di valutare sv una sola volta.

Si noti che non vi è alcuna garanzia che il valore restituito di "SvPV()" sia uguale a
"SvPVX(sv)", o che "SvPVX(sv)" contiene dati validi, o che successive chiamate a
"SvPV(sv)" restituirà ogni volta lo stesso valore del puntatore. Ciò è dovuto al modo
che vengono gestite cose come il sovraccarico e il Copy-On-Write. In questi casi, il
il valore restituito può puntare a un buffer temporaneo o simile. Se hai assolutamente bisogno
il campo SvPVX sia valido (ad esempio, se intendi scriverci), quindi vedi
"SvPV_force".

char* SvPV(SV* sv, STRLEN len)

SvPVbyte
Come "SvPV", ma converte prima sv in byte, se necessario.

char* SvPVbyte(SV* sv, STRLEN len)

SvPVbytex
Come "SvPV", ma converte prima sv in byte, se necessario.
Garanzie da valutare sv una sola volta; altrimenti usa il più efficiente "SvPVbyte".

char* SvPVbytex(SV* sv, STRLEN len)

SvPVbytex_force
Come "SvPV_force", ma converte prima sv in byte, se necessario.
Garanzie da valutare sv una sola volta; usa il più efficiente "SvPVbyte_force"
altrimenti.

char* SvPVbytex_force(SV* sv, STRLEN len)

SvPVbyte_force
Come "SvPV_force", ma converte prima sv in byte, se necessario.

char* SvPVbyte_force(SV* sv, STRLEN len)

SvPVbyte_nolen
Come "SvPV_nolen", ma converte prima sv in rappresentazione di byte, se necessario.

char* SvPVbyte_nolen(SV* sv)

SvPVutf8
Come "SvPV", ma converte prima sv in utf8 se necessario.

char* SvPVutf8(SV* sv, STRLEN len)

SvPVutf8x
Come "SvPV", ma converte prima sv in utf8 se necessario. Garanzie da valutare
sv solo una volta; altrimenti usa il più efficiente "SvPVutf8".

char* SvPVutf8x(SV* sv, STRLEN len)

SvPVutf8x_force
Come "SvPV_force", ma converte prima sv in utf8 se necessario. Garanzie a
valutare sv solo una volta; altrimenti usa il più efficiente "SvPVutf8_force".

char* SvPVutf8x_force(SV* sv, STRLEN len)

SvPVutf8_force
Come "SvPV_force", ma converte prima sv in utf8 se necessario.

char* SvPVutf8_force(SV* sv, STRLEN len)

SvPVutf8_nolen
Come "SvPV_nolen", ma converte prima sv in utf8 se necessario.

char* SvPVutf8_nolen(SV* sv)

SvPVX Restituisce un puntatore alla stringa fisica nell'SV. L'SV deve contenere una stringa.
Prima della 5.9.3 non era sicuro eseguire questa macro a meno che il tipo di SV non fosse >=
SVT_PV.

Viene utilizzato anche per memorizzare il nome di una subroutine caricata automaticamente in un XS AUTOLOAD
routine. Vedi "Caricamento automatico con XSUB" in perlguts.

carattere* SvPVX(SV* sv)

SvPVx Una versione di "SvPV" che garantisce di valutare "sv" solo una volta. Usalo solo se
"sv" è un'espressione con effetti collaterali, altrimenti usa il più efficiente "SvPV".

char* SvPVx(SV* sv, STRLEN len)

SvPV_forza
Come "SvPV", ma costringerà l'SV a contenere una stringa ("SvPOK") e solo a
stringa ("SvPOK_only"), con le buone o con le cattive. Hai bisogno di forza se hai intenzione di farlo
aggiorna direttamente "SvPVX". I processi diventano magici.

Si noti che forzare uno scalare arbitrario in un PV semplice potrebbe potenzialmente rimuovere
dati utili da esso. Ad esempio, se l'SV era "SvROK", il referente lo farà
hanno il conteggio di riferimento decrementato e lo stesso SV può essere convertito in an
Scalare "SvPOK" con un buffer di stringhe contenente un valore come "ARRAY(0x1234)".

char* SvPV_force(SV* sv, STRLEN len)

SvPV_force_nomg
Come "SvPV_force", ma non elabora la magia.

char* SvPV_force_nomg(SV* sv, STRLEN len)

SvPV_nolen
Come "SvPV" ma non imposta una variabile di lunghezza.

char* SvPV_nolen(SV* sv)

SvPV_nomg
Come "SvPV" ma non elabora la magia.

char* SvPV_nomg(SV* sv, STRLEN len)

SvPV_nomg_nolen
Come "SvPV_nolen" ma non elabora la magia.

char* SvPV_nomg_nolen(SV* sv)

SvPV_set
Questo probabilmente non è quello che vuoi usare, probabilmente volevi "sv_usepvn_flags"
o "sv_setpvn" o "sv_setpvs".

Impostare il valore del puntatore PV in "sv" sul Perl allocato "NUL"-terminato
stringa "val". Vedi anche "SvIV_set".

Ricordarsi di liberare il buffer FV precedente. Ci sono molte cose da controllare. Attenzione
che il puntatore esistente potrebbe essere coinvolto in copy-on-write o altri danni, quindi
fai "SvOOK_off(sv)" e usa "sv_force_normal" o "SvPV_force" (o controlla SvIsCOW
flag) prima per assicurarsi che questa modifica sia sicura. Quindi, infine, se non è a
COW, chiama "SvPV_free" per liberare il buffer fotovoltaico precedente.

void SvPV_set(SV* sv, char* val)

SvREFCNT
Restituisce il valore del conteggio dei riferimenti dell'oggetto.

U32 SvRIF.NT(SV* sv)

SvREFCNT_dec
Decrementa il conteggio dei riferimenti dell'SV specificato. sv potrebbe essere NULLO.

void SvREFCNT_dec(SV*sv)

SvREFCNT_dec_NN
Uguale a SvREFCNT_dec, ma può essere utilizzato solo se lo sai sv non è NULLA. Da quando noi
non è necessario controllare il NULLness, è più veloce e più piccolo.

void SvREFCNT_dec_NN(SV*sv)

SvREFCNT_inc
Incrementa il conteggio dei riferimenti dell'SV specificato, restituendo l'SV.

Tutte le seguenti macro SvREFCNT_inc* sono versioni ottimizzate di SvREFCNT_inc,
e può essere sostituito con SvREFCNT_inc.

SV* SvREFCNT_inc(SV* sv)

SvREFCNT_inc_NN
Uguale a SvREFCNT_inc, ma può essere utilizzato solo se lo sai sv non è NULLA. Da quando noi
non è necessario controllare il NULLness, è più veloce e più piccolo.

SV* SvREFCNT_inc_NN(SV* sv)

SvREFCNT_inc_semplice
Uguale a SvREFCNT_inc, ma può essere utilizzato solo con espressioni senza effetti collaterali.
Dal momento che non dobbiamo memorizzare un valore temporaneo, è più veloce.

SV* SvREFCNT_inc_semplice(SV* sv)

SvREFCNT_inc_simple_NN
Uguale a SvREFCNT_inc_simple, ma può essere utilizzato solo se lo sai sv non è NULLO.
Dal momento che non dobbiamo controllare il NULLness, è più veloce e più piccolo.

SV* SvREFCNT_inc_simple_NN(SV* sv)

SvREFCNT_inc_simple_void
Uguale a SvREFCNT_inc_simple, ma può essere utilizzato solo se non è necessario il reso
valore. Non è necessario che la macro restituisca un valore significativo.

void SvREFCNT_inc_simple_void(SV*sv)

SvREFCNT_inc_simple_void_NN
Uguale a SvREFCNT_inc, ma può essere utilizzato solo se non è necessario il valore restituito e
lo sai sv non è NULLA. La macro non ha bisogno di restituire un significato
value o controlla NULLness, quindi è più piccolo e più veloce.

void SvREFCNT_inc_simple_void_NN(SV*sv)

SvREFCNT_inc_void
Uguale a SvREFCNT_inc, ma può essere utilizzato solo se non è necessario il valore restituito.
Non è necessario che la macro restituisca un valore significativo.

void SvREFCNT_inc_void(SV*sv)

SvREFCNT_inc_void_NN
Uguale a SvREFCNT_inc, ma può essere utilizzato solo se non è necessario il valore restituito e
lo sai sv non è NULLA. La macro non ha bisogno di restituire un significato
value o controlla NULLness, quindi è più piccolo e più veloce.

void SvREFCNT_inc_void_NN(SV*sv)

SvROK Verifica se l'SV è un camper.

U32 SvROK(SV*sv)

SvROK_off
Disattiva lo stato RV di un SV.

void SvROK_off(SV*sv)

SvROK_on
Dice a un SV che è un camper.

void SvROK_on(SV*sv)

SvRV Dereferenzia un camper per restituire l'SV.

SV* SvRV(SV* sv)

SvRV_set
Impostare il valore del puntatore RV in sv su val. Vedere "SvIV_set".

void SvRV_set(SV* sv, SV* val)

SvSTASH Restituisce la scorta dell'SV.

HV* SvSTASH(SV* sv)

SvSTASH_set
Imposta il valore del puntatore STASH in sv su val. Vedere "SvIV_set".

void SvSTASH_set(SV* sv, HV* val)

SvTAINT Intacca un SV se la contaminazione è abilitata e se qualche input per l'espressione corrente
è contaminato, di solito una variabile, ma forse anche input impliciti come la localizzazione
impostazioni. "SvTAINT" propaga quella contaminazione agli output di un'espressione
in modo pessimista; cioè, senza prestare attenzione a quale
gli output sono influenzati da quali input.

void SvTAINT(SV*sv)

SvTAINTED
Verifica se un SV è contaminato. Restituisce TRUE se lo è, FALSE in caso contrario.

bool SvTAINTED(SV*sv)

SvTAINTED_off
Non contamina un SV. Essere molto attenzione con questa routine, poiché cortocircuita alcuni dei
Le caratteristiche di sicurezza fondamentali di Perl. Gli autori del modulo XS non dovrebbero usarlo
funzione a meno che non comprendano appieno tutte le implicazioni di incondizionatamente
intaccare il valore. La rimozione della contaminazione dovrebbe essere eseguita nel modo standard di Perl, tramite
un'espressione regolare accuratamente realizzata, piuttosto che variabili direttamente incontaminate.

void SvTAINTED_off(SV*sv)

SvTAINTED_on
Contrassegna un SV come contaminato se la contaminazione è abilitata.

void SvTAINTED_on(SV*sv)

SvTRUE Restituisce un valore booleano che indica se Perl valuterebbe l'SV come vero o falso.
See SvOK() per un test definito/non definito. Gestisce la magia "get" a meno che lo scalare non lo sia
già SvPOK, SvIOK o SvNOK (le bandiere pubbliche, non private).

bool SvTRUE(SV*sv)

SvTRUE_nomg
Restituisce un valore booleano che indica se Perl valuterebbe l'SV come vero o falso.
See SvOK() per un test definito/non definito. Non gestisce la magia 'ottenere'.

bool SvTRUE_nomg(SV*sv)

SvTYPE Restituisce il tipo di SV. Vedi "tipo sv".

svtype SvTYPE(SV* sv)

SvUOK Restituisce un valore booleano che indica se l'SV contiene un numero intero che deve essere
interpretato come non firmato. Un numero intero non negativo il cui valore è compreso nell'intervallo
di un IV e un UV possono essere contrassegnati come SvUOK o SVIOK.

bool SvUOK(SV*sv)

UPGRADE
Utilizzato per aggiornare un SV a una forma più complessa. Utilizza "sv_upgrade" per eseguire il
aggiornare se necessario. Vedi "tipo sv".

void SvUPGRADE(SV* sv, tipo sv)

SvUTF8 Restituisce un valore U32 che indica lo stato UTF-8 di un SV. Se le cose sono impostate
correttamente, questo indica se l'SV contiene o meno dati codificati UTF-8. Voi
dovrebbe usare questo dopo una chiamata a PVSV() o una delle sue varianti, in caso di chiamata a
il sovraccarico di stringhe aggiorna il flag interno.

Se vuoi prendere in considerazione il pragma dei byte, usa invece "DO_UTF8".

U32 SvUTF8(SV*sv)

SvUTF8_off
Disattiva lo stato UTF-8 di un SV (i dati non vengono modificati, solo il flag). Non
usare in modo frivolo.

void SvUTF8_off(SV *sv)

SvUTF8_on
Attiva lo stato UTF-8 di un SV (i dati non vengono modificati, solo il flag). Fare
non usare in modo frivolo.

void SvUTF8_on(SV *sv)

SvUV Costringe l'SV specificato a un numero intero senza segno e lo restituisce. Vedere "SvUVx" per a
versione che garantisce di valutare sv una sola volta.

UVSvUV(SV*sv)

SvUVX Restituisce il valore grezzo nello slot UV dell'SV, senza controlli o conversioni. Solo
usa quando sei sicuro che SvIOK sia vero. Vedi anche "SvUV()".

UVSvUVX(SV*sv)

SvUVx Forza l'SV specificato a un numero intero senza segno e lo restituisce. Garanzie a
valutare "sv" solo una volta. Usalo solo se "sv" è un'espressione con lato
effetti, altrimenti usa il più efficiente "SvUV".

UV SvUVx(SV*sv)

SvUV_nomg
Come "SvUV" ma non elabora la magia.

UVSvUV_nomg(SV*sv)

SvUV_set
Imposta il valore del puntatore UV in sv su val. Vedere "SvIV_set".

void SvUV_set(SV* sv, UV val)

SvVOK Restituisce un valore booleano che indica se l'SV contiene una v-string.

bool SvVOK(SV*sv)

sv_catpvn_nomg
Come "sv_catpvn" ma non elabora la magia.

void sv_catpvn_nomg(SV* sv, const char* ptr,
STRLEN lente)

sv_catpv_nomg
Come "sv_catpv" ma non elabora la magia.

void sv_catpv_nomg(SV* sv, const char* ptr)

sv_catsv_nomg
Come "sv_catsv" ma non elabora la magia.

void sv_catsv_nomg(SV* dsv, SV* ssv)

sv_derivato_da
Esattamente come "sv_derived_from_pv", ma non accetta un parametro "flags".

bool sv_derived_from(SV* sv, const char *const nome)

sv_derivato_da_pv
Esattamente come "sv_derived_from_pvn", ma prende una stringa con terminazione nul invece di una
coppia stringa/lunghezza.

bool sv_derivato_da_pv(SV* sv,
const char *const nome,
bandiere U32)

sv_derivato_da_pvn
Restituisce un valore booleano che indica se l'SV è derivato dalla classe specificata at
, il C livello. Per verificare la derivazione a livello di Perl, chiama "isa()" come un normale Perl
metodo.

Attualmente, l'unico valore significativo per "flags" è SVf_UTF8.

bool sv_derivato_da_pvn(SV* sv,
const char *const nome,
const STRLEN len, flag U32)

sv_derivato_da_sv
Esattamente come "sv_derived_from_pvn", ma prende la stringa del nome sotto forma di SV
invece di una coppia stringa/lunghezza.

bool sv_derivato_da_sv(SV* sv, SV *nomiv,
bandiere U32)

sv_does Come "sv_does_pv", ma non accetta un parametro "flags".

bool sv_does(SV* sv, const char *const nome)

sv_fa_pv
Come "sv_does_sv", ma accetta una stringa con terminazione nul invece di un SV.

bool sv_does_pv(SV* sv, const char *const nome,
bandiere U32)

sv_fa_pvn
Come "sv_does_sv", ma accetta una coppia stringa/lunghezza invece di un SV.

bool sv_does_pvn(SV* sv, const char *const nome,
const STRLEN len, flag U32)

sv_fa_sv
Restituisce un valore booleano che indica se SV esegue un ruolo specifico con nome. Il
SV può essere un oggetto Perl o il nome di una classe Perl.

bool sv_does_sv(SV* sv, SV* nomiv, flag U32)

sv_report_used
Scarica il contenuto di tutti gli SV non ancora liberati (aiuto per il debug).

void sv_report_used()

sv_setsv_nomg
Come "sv_setsv" ma non elabora la magia.

void sv_setsv_nomg(SV* dsv, SV* ssv)

sv_utf8_upgrade_nomg
Come sv_utf8_upgrade, ma non fa magie su "sv".

STRLEN sv_utf8_upgrade_nomg(NN SV *sv)

SV-Corpo assegnazione

numero_simile
Verifica se il contenuto di un SV sembra un numero (o è un numero). "Inf" e
"Infinity" sono trattati come numeri (quindi non emetteranno un avviso non numerico), anche
se tuo atof() non li grok. Get-magic viene ignorato.

I32 sembra_come_numero(SV *const sv)

nuovoRV_noinc
Crea un wrapper RV per un SV. Il conteggio dei riferimenti per l'SV originale è non è un
incrementato.

SV* newRV_noinc(SV *const tmpRef)

newSV Crea un nuovo SV. Un parametro "len" diverso da zero indica il numero di byte di
spazio di stringa preallocato che dovrebbe avere SV. Un byte extra per un "NUL" finale
è anche riservato. (SvPOK non è impostato per SV anche se lo spazio stringa lo è
assegnato.) Il conteggio di riferimento per il nuovo SV è impostato su 1.

Nel 5.9.3, nuovoSV() sostituisce il più vecchio NOTIZIEV() API e rilascia il primo parametro,
x, un aiuto per il debug che consentiva ai chiamanti di identificarsi. Questo aiuto è stato
sostituito da una nuova opzione di compilazione, PERL_MEM_LOG (vedere "PERL_MEM_LOG" in
perlhacktips). L'API precedente è ancora lì per l'uso nel supporto dei moduli XS
perl più vecchi.

SV* nuovoSV(const STRLEN len)

nuovoSVhek
Crea un nuovo SV dalla struttura della chiave hash. Genererà scalari che puntano
alla tabella delle stringhe condivisa ove possibile. Restituisce un nuovo SV (non definito) se il
hek è NULL.

SV* nuovoSVhek(cost HEK *cost hek)

newSViv Crea un nuovo SV e vi copia un numero intero. Il conteggio di riferimento per SV è
impostato su 1.

SV* nuovoSViv(const IV i)

newSVnv Crea un nuovo SV e vi copia un valore in virgola mobile. Il conteggio di riferimento
per SV è impostato su 1.

SV* nuovoSVnv(const NV n)

newSVpv Crea un nuovo SV e copia una stringa (che può contenere caratteri "NUL" ("\0"))
dentro. Il conteggio dei riferimenti per SV è impostato su 1. Se "len" è zero, Perl lo farà
calcola la lunghezza usando strlen (), (il che significa che se usi questa opzione, quella "s"
non può contenere caratteri "NUL" incorporati e deve avere un byte "NUL" di terminazione).

Per efficienza, prendi in considerazione l'utilizzo di "newSVpvn".

SV* newSVpv(const char *const s, const STRLEN len)

nuovoSVpvf
Crea un nuovo SV e lo inizializza con la stringa formattata come "sprintf".

SV* newSVpvf(const char *const pat, ...)

nuovoSVpvn
Crea un nuovo SV e vi copia una stringa, che può contenere caratteri "NUL".
("\0") e altri dati binari. Il conteggio di riferimento per SV è impostato su 1. Nota
che se "len" è zero, Perl creerà una stringa di lunghezza zero (Perl). Sei
responsabile di garantire che il buffer di origine sia lungo almeno "len" byte. Se
l'argomento "buffer" è NULL il nuovo SV sarà indefinito.

SV* newSVpvn(const char *const s, const STRLEN len)

newSVpvn_flags
Crea un nuovo SV e copia una stringa (che può contenere caratteri "NUL" ("\0"))
dentro. Il conteggio dei riferimenti per SV è impostato su 1. Si noti che se "len" è zero,
Perl creerà una stringa di lunghezza zero. Sei responsabile di garantire che il
la stringa di origine è lunga almeno "len" byte. Se l'argomento "s" è NULL il nuovo
SV sarà indefinito. Attualmente gli unici flag bit accettati sono "SVf_UTF8" e
"SVs_TEMP". Se "SVs_TEMP" è impostato, sul risultato viene chiamato "sv_2mortal()".
prima del ritorno. Se "SVf_UTF8" è impostato, "s" è considerato in UTF-8 e the
Il flag "SVf_UTF8" verrà impostato sul nuovo SV. "newSVpvn_utf8()" è una comodità
wrapper per questa funzione, definito come

#define newSVpvn_utf8(s, len, u) \
newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)

SV* newSVpvn_flags(const char *const s,
const STRLEN lente,
const bandiere U32)

newSVpvn_share
Crea un nuovo SV con il relativo SvPVX_const che punta a una stringa condivisa nella stringa
tavolo. Se la stringa non esiste già nella tabella, viene creata per prima.
Attiva il flag SvIsCOW (o READONLY e FAKE in 5.16 e versioni precedenti). Se la
Il parametro "hash" è diverso da zero, viene utilizzato quel valore; altrimenti viene calcolato l'hash.
L'hash della stringa può essere successivamente recuperato dall'SV con "SvSHARED_HASH ()"
macro. L'idea qui è che la tabella delle stringhe viene utilizzata per le chiavi hash condivise
queste stringhe avranno SvPVX_const == HeKEY e la ricerca dell'hash eviterà la stringa
confrontare.

SV* newSVpvn_share(const char* s, I32 len, U32 hash)

nuovoSVpvs
Come "newSVpvn", ma accetta una stringa letterale con terminazione "NUL" invece di a
coppia stringa/lunghezza.

SV* newSVpvs(const char* s)

nuovoSVpvs_flags
Come "newSVpvn_flags", ma accetta una stringa letterale con terminazione "NUL" invece di un
coppia stringa/lunghezza.

SV* newSVpvs_flags(const char* s, flag U32)

newSVpvs_share
Come "newSVpvn_share", ma accetta una stringa letterale con terminazione "NUL" invece di un
coppia stringa/lunghezza e omette il parametro hash.

SV* newSVpvs_share(const char* s)

newSVpv_share
Come "newSVpvn_share", ma accetta una stringa con terminazione "NUL" invece di a
coppia stringa/lunghezza.

SV* newSVpv_share(const char* s, hash U32)

newSVrv Crea un nuovo SV per il RV esistente, "rv", a cui puntare. Se "rv" non è un camper
quindi verrà aggiornato a uno. Se "classname" non è nullo, il nuovo SV lo farà
essere benedetto nel pacchetto specificato. Viene restituito il nuovo SV e il suo riferimento
count è 1. Il conteggio di riferimento 1 è di proprietà di "rv".

SV* newSVrv(SV *const rv,
const char *const nomeclasse)

newSVsv Crea un nuovo SV che è un duplicato esatto dell'SV originale. (Usa
"sv_setsv".)

SV* nuovoSVsv(SV *const vecchio)

newSVuv Crea un nuovo SV e vi copia un numero intero senza segno. Il conteggio di riferimento per
l'SV è impostato su 1.

SV* nuovoSVuv(const UV u)

nuovoSV_tipo
Crea un nuovo SV, del tipo specificato. Il conteggio di riferimento per il nuovo SV è
impostato su 1.

SV* newSV_type(const svtype tipo)

sv_2bool
Questa macro è utilizzata solo da sv_true() o il suo equivalente macro, e solo se il
l'argomento di quest'ultimo non è né SvPOK, SvIOK né SvNOK. Chiama sv_2bool_flags con
il flag SV_GMAGIC.

bool sv_2bool(SV *const sv)

sv_2bool_flags
Questa funzione è utilizzata solo da sv_true() e amici, e solo se di questi ultimi
argomento non è né SvPOK, SvIOK né SvNOK. Se i flag contengono SV_GMAGIC, allora
fa un mg_get() prima.

bool sv_2bool_flags(SV *sv, flag I32)

sv_2cv Usando varie mosse, cerca di ottenere un CV da un SV; inoltre, prova se possibile a
imposta *st e *gvp allo stash e al GV ad esso associato. I flag in "lref" sono
passato a gv_fetchsv.

CV* sv_2cv(SV* sv, HV **cost st, GV **cost gvp,
cost I32 lref)

sv_2io Usando varie mosse, cerca di ottenere un IO da un SV: lo slot IO se è un GV; O
il risultato ricorsivo se siamo un camper; o lo slot IO del simbolo che prende il nome da
PV se siamo una stringa.

La magia "Get" viene ignorata sulla sv passata, ma verrà chiamata su "SvRV(sv)" se sv
è un camper.

IO* sv_2io(SV *const sv)

sv_2iv_flags
Restituisce il valore intero di un SV, eseguendo qualsiasi conversione di stringa necessaria. Se
flags include SV_GMAGIC, fa an mg_get() Primo. Normalmente utilizzato tramite il
Macro "SvIV(sv)" e "SvIVx(sv)".

IV sv_2iv_flags(SV *const sv, const I32 flag)

sv_2mortale
Contrassegna un SV esistente come mortale. L'SV sarà distrutto "presto", sia da un
chiamata esplicita a FREETMPS, o da una chiamata implicita in posizioni come statement
confini. SvTEMP() è attivato, il che significa che il buffer delle stringhe di SV può essere
"rubato" se questo SV viene copiato. Vedi anche "sv_newmortal" e "sv_mortalcopy".

SV* sv_2mortale(SV *const sv)

sv_2nv_flags
Restituisce il valore num di un SV, eseguendo qualsiasi stringa o conversione intera necessaria.
Se flags include SV_GMAGIC, fa an mg_get() Primo. Normalmente utilizzato tramite il
Macro "SvNV(sv)" e "SvNVx(sv)".

NV sv_2nv_flags(SV *const sv, const I32 flag)

sv_2pvbyte
Restituisce un puntatore alla rappresentazione codificata in byte dell'SV e imposta *lp su its
lunghezza. Può causare il downgrade di SV da UTF-8 come effetto collaterale.

Di solito si accede tramite la macro "SvPVbyte".

char* sv_2pvbyte(SV *sv, STRLEN *const lp)

sv_2pvutf8
Restituisce un puntatore alla rappresentazione con codifica UTF-8 di SV e imposta *lp su its
lunghezza. Può causare l'aggiornamento di SV a UTF-8 come effetto collaterale.

Di solito si accede tramite la macro "SvPVutf8".

char* sv_2pvutf8(SV *sv, STRLEN *const lp)

sv_2pv_flags
Restituisce un puntatore al valore stringa di un SV e imposta *lp sulla sua lunghezza. Se
flags include SV_GMAGIC, fa an mg_get() Primo. Costringe sv a una stringa if
necessario. Normalmente richiamato tramite la macro "SvPV_flags". "sv_2pv()" e
"sv_2pv_nomg" di solito finisce anche qui.

char* sv_2pv_flags(SV *const sv, STRLEN *const lp,
cost I32 flag)

sv_2uv_flags
Restituisce il valore intero senza segno di un SV, eseguendo qualsiasi conversione di stringa necessaria.
Se flags include SV_GMAGIC, fa an mg_get() Primo. Normalmente utilizzato tramite il
Macro "SvUV(sv)" e "SvUVx(sv)".

UV sv_2uv_flags(SV *const sv, const I32 flag)

sv_backoff
Rimuovi qualsiasi offset di stringa. Normalmente dovresti usare il macro wrapper "SvOOK_off".
anziché.

int sv_backoff(SV *const sv)

sv_bless
Benedice un SV in un pacchetto specificato. L'SV deve essere un camper. Il pacchetto deve
essere designato dalla sua scorta (vedi "gv_stashpv()"). Il conteggio di riferimento dell'SV è
inalterato.

SV* sv_bless(SV *const sv, HV *const stash)

sv_catpv
Concatena la stringa con terminazione "NUL" alla fine della stringa in cui si trova
la S.V. Se l'SV ha lo stato UTF-8 impostato, i byte aggiunti dovrebbero esserlo
UTF-8 valido. Gestisce la magia "ottieni", ma non la magia "imposta". Vedere "sv_catpv_mg".

void sv_catpv(SV *const sv, const char* ptr)

sv_catpvf
Elabora i suoi argomenti come "sprintf" e aggiunge l'output formattato a un SV.
Se i dati aggiunti contengono caratteri "larghi" (inclusi, ma non limitati a,
SV con PV UTF-8 formattato con %s e caratteri >255 formattati con %c), il
SV originale potrebbe essere aggiornato a UTF-8. Gestisce la magia "ottieni", ma non "imposta"
Magia. Vedere "sv_catpvf_mg". Se l'SV originale era UTF-8, lo schema dovrebbe esserlo
UTF-8 valido; se l'SV originale era byte, dovrebbe esserlo anche il modello.

void sv_catpvf(SV *const sv, const char *const pat,
...)

sv_catpvf_mg
Come "sv_catpvf", ma gestisce anche la magia "set".

void sv_catpvf_mg(SV *const sv,
const carattere *const pat, ...)

sv_catpvn
Concatena la stringa alla fine della stringa che si trova nell'SV. Il "lento"
indica il numero di byte da copiare. Se l'SV ha lo stato UTF-8 impostato, allora il file
i byte aggiunti devono essere UTF-8 validi. Gestisce la magia "ottieni", ma non la magia "imposta".
Vedere "sv_catpvn_mg".

void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)

sv_catpvn_flags
Concatena la stringa alla fine della stringa che si trova nell'SV. Il "lento"
indica il numero di byte da copiare.

Per impostazione predefinita, si presume che la stringa aggiunta sia UTF-8 valida se SV ha l'estensione
Stato UTF-8 impostato e altrimenti una stringa di byte. Si può forzare l'allegato
stringa da interpretare come UTF-8 fornendo il flag "SV_CATUTF8" e come byte
fornendo il flag "SV_CATBYTES"; sarà l'SV o la stringa aggiunta
aggiornato a UTF-8 se necessario.

Se "flags" ha il bit "SV_SMAGIC" impostato, sarà "mg_set" su "dsv" in seguito se
adeguata. "sv_catpvn" e "sv_catpvn_nomg" sono implementati in termini di questo
funzione.

void sv_catpvn_flags(SV *const dstr,
const carattere *sstr,
const STRLEN lente,
cost I32 flag)

sv_catpvs
Come "sv_catpvn", ma accetta una stringa letterale invece di una coppia stringa/lunghezza.

void sv_catpvs(SV* sv, const char* s)

sv_catpvs_flags
Come "sv_catpvn_flags", ma accetta una stringa letterale con terminazione "NUL" invece di una
coppia stringa/lunghezza.

void sv_catpvs_flags(SV* sv, const char* s,
bandiere I32)

sv_catpvs_mg
Come "sv_catpvn_mg", ma accetta una stringa letterale invece di una coppia stringa/lunghezza.

void sv_catpvs_mg(SV* sv, const char* s)

sv_catpvs_nomg
Come "sv_catpvn_nomg", ma prende una stringa letterale invece di una coppia stringa/lunghezza.

void sv_catpvs_nomg(SV* sv, const char* s)

sv_catpv_flags
Concatena la stringa con terminazione "NUL" alla fine della stringa in cui si trova
la S.V. Se l'SV ha lo stato UTF-8 impostato, i byte aggiunti dovrebbero esserlo
UTF-8 valido. Se "flags" ha il bit "SV_SMAGIC" impostato, sarà "mg_set" sul file
SV modificato se appropriato.

void sv_catpv_flags(SV *dstr, const char *sstr,
cost I32 flag)

sv_catpv_mg
Come "sv_catpv", ma gestisce anche la magia "set".

void sv_catpv_mg(SV *const sv, const char *const ptr)

sv_catsv
Concatena la stringa da SV "ssv" alla fine della stringa in SV "dsv". Se
"ssv" è nullo, non fa nulla; altrimenti modifica solo "dsv". Gestisce la magia "prendi".
su entrambi gli SV, ma nessuna magia "set". Vedere "sv_catsv_mg" e "sv_catsv_nomg".

void sv_catsv(SV *dstr, SV *sstr)

sv_catsv_flags
Concatena la stringa da SV "ssv" alla fine della stringa in SV "dsv". Se
"ssv" è nullo, non fa nulla; altrimenti modifica solo "dsv". Se "flag" include
Bit "SV_GMAGIC" impostato, chiamerà "mg_get" su entrambi gli SV se appropriato. Se "bandiere"
include "SV_SMAGIC", "mg_set" verrà chiamato in seguito sull'SV modificato, if
adeguata. "sv_catsv", "sv_catsv_nomg" e "sv_catsv_mg" sono implementati in
termini di questa funzione.

void sv_catsv_flags(SV *const dsv, SV *const ssv,
cost I32 flag)

sv_chop Rimozione efficiente dei caratteri dall'inizio del buffer delle stringhe.
SvPOK(sv), o almeno SvPOKp(sv), deve essere vero e il "ptr" deve essere un puntatore a
da qualche parte all'interno del buffer delle stringhe. Il "ptr" diventa il primo carattere del
corda regolata. Utilizza l'"hack OOK". Al ritorno, solo SvPOK(sv) e SvPOKp(sv)
tra i flag OK sarà vero.

Attenzione: dopo che questa funzione ritorna, "ptr" e SvPVX_const(sv) potrebbero non fare più riferimento
allo stesso blocco di dati.

La sfortunata somiglianza del nome di questa funzione con quello di "chop" di Perl
operatore è strettamente casuale. Questa funzione funziona da sinistra; "taglio"
funziona da destra.

void sv_chop(SV *const sv, const char *const ptr)

sv_clear
Cancella un SV: chiama eventuali distruttori, libera qualsiasi memoria utilizzata dal corpo e libera
il corpo stesso. La testa della SV è non è un freed, anche se il suo tipo è impostato su tutti 1
in modo che non si presuma inavvertitamente che sia vivo durante la distruzione globale
ecc. Questa funzione dovrebbe essere chiamata solo quando REFCNT è zero. La maggior parte delle volte
ti consigliamo invece di chiamare "sv_free()" (o il suo macro wrapper "SvREFCNT_dec").

void sv_clear(SV *const orig_sv)

sv_cmp Confronta le stringhe in due SV. Restituisce -1, 0 o 1 indicando se il
la stringa in "sv1" è minore, uguale o maggiore della stringa in "sv2". È
UTF-8 e "usa i byte" sono consapevoli, gli handle ottengono la magia e costringeranno i suoi argomenti a
stringhe se necessario. Vedi anche "sv_cmp_locale".

I32 sv_cmp(SV *cost sv1, SV *cost sv2)

sv_cmp_flags
Confronta le stringhe in due SV. Restituisce -1, 0 o 1 indicando se il
la stringa in "sv1" è minore, uguale o maggiore della stringa in "sv2". È
UTF-8 e 'usa byte' sono consapevoli e, se necessario, costringeranno i suoi argomenti a stringhe. Se
i flag includono SV_GMAGIC, gestisce get magic. Guarda anche
"sv_cmp_locale_flags".

I32 sv_cmp_flags(SV *const sv1, SV *const sv2,
const bandiere U32)

sv_cmp_locale
Confronta le stringhe in due SV in modo che riconosca le impostazioni locali. Si UTF-8 e' uso
i byte sono consapevoli, gli handle diventano magici e, se necessario, costringeranno i suoi argomenti a stringhe.
Vedere anche "sv_cmp".

I32 sv_cmp_locale(SV *const sv1, SV *const sv2)

sv_cmp_locale_flags
Confronta le stringhe in due SV in modo che riconosca le impostazioni locali. Si UTF-8 e' uso
bytes' consapevole e costringerà i suoi argomenti a stringhe se necessario. Se le bandiere
contenere SV_GMAGIC, gestisce get magic. Vedere anche "sv_cmp_flags".

I32 sv_cmp_locale_flags(SV *const sv1,
SV *cost sv2,
const bandiere U32)

sv_collxfrm
Questo chiama "sv_collxfrm_flags" con il flag SV_GMAGIC. Vedere "sv_collxfrm_flags".

char* sv_collxfrm(SV *const sv, STRLEN *const nxp)

sv_collxfrm_flags
Aggiungi la magia Collate Transform a un SV se non ce l'ha già. Se le bandiere
contenere SV_GMAGIC, gestisce get-magic.

Qualsiasi variabile scalare può contenere la magia PERL_MAGIC_collxfrm che contiene lo scalare
dati della variabile, ma trasformati in un formato tale che una memoria normale
confronto può essere utilizzato per confrontare i dati in base alle impostazioni locali.

char* sv_collxfrm_flags(SV *const sv,
STRLEN *const nxp,
I32 const flag)

sv_copypv_flags
Implementazione di sv_copypv e sv_copypv_nomg. Le chiamate diventano magiche se i flag includono
SV_GMAGIC.

void sv_copypv_flags(SV *const dsv, SV *const ssv,
cost I32 flag)

sv_copypv_nomg
Come sv_copypv, ma non richiama prima la magia.

void sv_copypv_nomg(SV *const dsv, SV *const ssv)

sv_dec Decremento automatico del valore nell'SV, eseguendo la conversione da stringa a numerica se
necessario. Gestisce la magia "get" e l'overload dell'operatore.

void sv_dec(SV *const sv)

sv_dec_nomg
Decremento automatico del valore nell'SV, eseguendo la conversione da stringa a numerica se
necessario. Gestisce il sovraccarico dell'operatore. Salta la gestione della magia "prendi".

void sv_dec_nomg(SV *const sv)

sv_eq Restituisce un valore booleano che indica se le stringhe nei due SV sono identiche. È
UTF-8 e "usa i byte" sono consapevoli, gli handle ottengono la magia e costringeranno i suoi argomenti a
stringhe se necessario.

I32 sv_eq(SV* sv1, SV* sv2)

sv_eq_flags
Restituisce un valore booleano che indica se le stringhe nei due SV sono identiche. È
UTF-8 e 'usa byte' sono consapevoli e forza i suoi argomenti in stringhe se necessario. Se la
flag includono SV_GMAGIC, gestisce anche get-magic.

I32 sv_eq_flags(SV* sv1, SV* sv2, const U32 flag)

sv_force_normal_flags
Annulla vari tipi di fake su un SV, dove fakery significa "più di" una stringa: if
il PV è una stringa condivisa, creane una copia privata; se siamo un arbitro, smettila di arbitrare; Se
siamo un glob, downgrade a xpvmg; se siamo uno scalare copy-on-write, questo è il
tempo di scrittura in cui eseguiamo la copia e viene utilizzato anche localmente; se questa è una vstring,
lascia cadere la magia di vstring. Se "SV_COW_DROP_PV" è impostato, uno scalare copy-on-write
rilascia il suo buffer PV (se presente) e diventa SvPOK_off invece di crearne una copia.
(Usato dove questo scalare sta per essere impostato su un altro valore.) Inoltre, il
Il parametro "flags" viene passato a "sv_unref_flags()" durante l'unreffing.
"sv_force_normal" chiama questa funzione con i flag impostati su 0.

Questa funzione dovrebbe essere usata per segnalare a perl che questo SV sta per essere
scritto a, e qualsiasi contabilità extra deve essere curata. Quindi, esso
gracchia sui valori di sola lettura.

void sv_force_normal_flags(SV *const sv,
const bandiere U32)

sv_free Decrementa il conteggio dei riferimenti di un SV e, se scende a zero, chiama "sv_clear" per
invocare distruttori e liberare qualsiasi memoria utilizzata dal corpo; infine, deallocare
la stessa testa della SV. Normalmente chiamato tramite una macro wrapper "SvREFCNT_dec".

void sv_libero(SV *const sv)

sv_gets Prende una riga dal filehandle e la memorizza nell'SV, opzionalmente aggiungendo a
la stringa attualmente memorizzata. Se "append" non è 0, la riga viene aggiunta allo SV
invece di sovrascriverlo. "append" dovrebbe essere impostato sull'offset di byte che il file
la stringa aggiunta dovrebbe iniziare da in SV (tipicamente, "SvCUR(sv)" è un adatto
scelta).

char* sv_gets(SV *const sv, PerlIO *const fp,
I32 aggiungo)

sv_get_backrefs
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Se sv è l'obiettivo di un riferimento debole, restituisce i riferimenti indietro
struttura associata alla sv; altrimenti restituisce NULL.

Quando si restituisce un risultato non nullo, il tipo di restituzione è rilevante. Se è un
AV allora gli elementi dell'AV sono i deboli RV di riferimento che puntano a questo
articolo. Se è di qualsiasi altro tipo, l'elemento stesso è il riferimento debole.

Vedi anche Perl_sv_add_backref(), Perl_sv_del_backref(), Perl_sv_kill_backrefs()

SV* sv_get_backrefs(SV *const sv)

sv_grow Espande il buffer dei caratteri nell'SV. Se necessario, utilizza "sv_unref" e
aggiorna SV a "SVt_PV". Restituisce un puntatore al buffer dei caratteri. Usa il
Wrapper "SvGROW" invece.

char* sv_grow(SV *const sv, STRLEN newlen)

sv_inc Incremento automatico del valore nell'SV, conversione da stringa a numerica se
necessario. Gestisce la magia "get" e l'overload dell'operatore.

void sv_inc(SV *const sv)

sv_inc_nomg
Incremento automatico del valore nell'SV, eseguendo la conversione da stringa a numerica se
necessario. Gestisce il sovraccarico dell'operatore. Salta la gestione della magia "prendi".

void sv_inc_nomg(SV *const sv)

sv_inserisci
Inserisce una stringa all'offset/lunghezza specificata all'interno dell'SV. Simile al
Perl sottostr() funzione. Le maniglie diventano magiche.

void sv_insert(SV *const bigstr, const STRLEN offset,
const STRLEN lente,
const char *const poco,
const STRLEN littlelen)

sv_insert_flags
Uguale a "sv_insert", ma i "flag" aggiuntivi vengono passati a "SvPV_force_flags"
questo vale per "bigstr".

void sv_insert_flags(SV *const bigstr,
const STRLEN offset,
const STRLEN lente,
const char *const poco,
const STRLEN littlelen,
const bandiere U32)

sv_isa Restituisce un valore booleano che indica se l'SV è inserito nella classe specificata.
Questo non controlla i sottotipi; usa "sv_derived_from" per verificare un'ereditarietà
rapporto.

int sv_isa(SV* sv, const char *const nome)

sv_isoggetto
Restituisce un valore booleano che indica se SV è un RV che punta a un oggetto benedetto.
Se l'SV non è un camper, o se l'oggetto non è benedetto, questo tornerà
falsa.

int sv_isoggetto(SV* sv)

sv_len Restituisce la lunghezza della stringa nell'SV. Gestisce la magia e la coercizione di tipo e
imposta il flag UTF8 in modo appropriato. Vedi anche "SvCUR", che fornisce l'accesso raw al file
slot xpv_cur.

STRLEN sv_len(SV *const sv)

sv_len_utf8
Restituisce il numero di caratteri nella stringa in un SV, contando i byte UTF-8 ampi
come un singolo personaggio. Gestisce la magia e la coercizione del tipo.

STRLEN sv_len_utf8(SV *const sv)

sv_magic
Aggiunge magia a un SV. Prima aggiorna "sv" per digitare "SVt_PVMG" se necessario, quindi
aggiunge un nuovo oggetto magico di tipo "come" all'inizio della lista magica.

Vedere "sv_magicext" (che "sv_magic" ora chiama) per una descrizione della gestione
degli argomenti "nome" e "namlen".

Devi usare "sv_magicext" per aggiungere magia agli SV SvREADONLY e anche per aggiungerne altri
di un'istanza dello stesso "come".

void sv_magic(SV *const sv, SV *const oggetto,
const int come, const char *const name,
const I32 nome)

sv_magicext
Aggiunge magia a un SV, potenziandolo se necessario. Applica il vtable fornito e
restituisce un puntatore alla magia aggiunta.

Nota che "sv_magicext" consentirà cose che "sv_magic" non consentirà. In
in particolare, puoi aggiungere magic a SvREADONLY SV e aggiungere più di un'istanza di
lo stesso "come".

Se "namlen" è maggiore di zero allora un "savepvn" copia di "nome" è memorizzato, se
"namlen" è zero, quindi "name" viene memorizzato così com'è e, come altro caso speciale, if
"(nome && namlen == HEf_SVKEY)" allora si presume che "nome" contenga un "SV*" ed è
memorizzato così com'è con REFCNT incrementato.

(Questo è ora usato come subroutine da "sv_magic".)

MAGIC * sv_magicext(SV *const sv, SV *const oggetto,
const int come,
const MGVTBL *const vtbl,
const char *const nome,
const I32 nome)

sv_mortalcopy
Crea un nuovo SV che è una copia dell'SV originale (utilizzando "sv_setsv"). Il nuovo
SV è contrassegnato come mortale. Verrà distrutto "presto", tramite una chiamata esplicita
a FREETMPS o tramite una chiamata implicita in luoghi come i limiti delle istruzioni. Vedere
anche "sv_newmortal" e "sv_2mortal".

SV* sv_mortalcopy(SV *const oldsv)

sv_newmortal
Crea un nuovo SV nullo che è mortale. Il conteggio dei riferimenti dell'SV è impostato su 1.
Verrà distrutto "presto", da una chiamata esplicita a FREETMPS, o da un
chiamata implicita in luoghi come i limiti delle istruzioni. Vedi anche "sv_mortalcopy"
e "sv_2mortal".

SV* sv_nuovomortale()

sv_newref
Incrementa il conteggio dei riferimenti di un SV. Utilizzare invece il wrapper "SvREFCNT_inc()".

SV* sv_nuovorif(SV *const sv)

sv_pos_b2u
Converte il valore indicato da offsetp da un conteggio di byte dall'inizio di
la stringa, a un conteggio del numero equivalente di caratteri UTF-8. Gestisce la magia e
tipo coercizione.

Utilizzare preferibilmente "sv_pos_b2u_flags", che gestisce correttamente le stringhe più lunghe di
2 GB.

void sv_pos_b2u(SV *const sv, I32 *const offsetp)

sv_pos_b2u_flags
Converte l'offset da un conteggio di byte dall'inizio della stringa in un conteggio
del numero equivalente di caratteri UTF-8. Gestisce la coercizione di tipo. bandiere è passato
a "SvPV_flags", e di solito dovrebbe essere "SV_GMAGIC|SV_CONST_RETURN" da gestire
magia.

STRLEN sv_pos_b2u_flags(SV *const sv,
STRLEN const offset, flag U32)

sv_pos_u2b
Converte il valore puntato da offsetp da un conteggio di caratteri UTF-8 da
inizio della stringa, a un conteggio del numero equivalente di byte; se lenp non è
zero, fa lo stesso con lenp, ma questa volta partendo dall'offset, piuttosto
che dall'inizio della stringa. Gestisce la magia e la coercizione del tipo.

Utilizzare preferibilmente "sv_pos_u2b_flags", che gestisce correttamente le stringhe più lunghe di
2 GB.

void sv_pos_u2b(SV *const sv, I32 *const offsetp,
I32 *const lente)

sv_pos_u2b_flags
Converte l'offset da un conteggio di caratteri UTF-8 dall'inizio della stringa in a
conteggio del numero equivalente di byte; se lenp è diverso da zero, fa lo stesso con
lenp, ma questa volta partendo dall'offset, piuttosto che dall'inizio del file
corda. Gestisce la coercizione di tipo. bandiere viene passato a "SvPV_flags" e di solito
dovrebbe essere "SV_GMAGIC|SV_CONST_RETURN" per gestire la magia.

STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset,
STRLEN *const lenp, flag U32)

sv_pvbyten_force
Il backend per la macro "SvPVbytex_force". Usa sempre la macro invece.

char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)

sv_pvn_force
Ottieni una stringa ragionevole dall'SV in qualche modo. Un'implementazione privata di
Macro "SvPV_force" per compilatori che non possono gestire espressioni macro complesse.
Usa sempre la macro invece.

char* sv_pvn_force(SV* sv, STRLEN* lp)

sv_pvn_force_flags
Ottieni una stringa ragionevole dall'SV in qualche modo. Se "flags" ha il bit "SV_GMAGIC" impostato,
will "mg_get" su "sv" se appropriato, altrimenti no. "sv_pvn_force" e
"sv_pvn_force_nomg" sono implementati in termini di questa funzione. Normalmente vuoi
per usare invece le varie macro wrapper: vedi "SvPV_force" e "SvPV_force_nomg"

char* sv_pvn_force_flags(SV *const sv,
STRLEN *const lp,
cost I32 flag)

sv_pvutf8n_force
Il backend per la macro "SvPVutf8x_force". Usa sempre la macro invece.

char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)

sv_reftype
Restituisce una stringa che descrive a cosa fa riferimento SV.

const char* sv_reftype(const SV *const sv, const int ob)

sv_replace
Rendere il primo argomento una copia del secondo, quindi eliminare l'originale. IL
la SV di destinazione assume fisicamente la proprietà del corpo della SV di origine e
eredita le sue bandiere; tuttavia, il bersaglio conserva tutta la magia che possiede e tutta la magia contenuta
la fonte viene scartata. Si noti che questa è una copia SV piuttosto specialistica
funzionamento; la maggior parte delle volte vorrai usare "sv_setsv" o una delle sue tante macro
front-end.

void sv_replace(SV *const sv, SV *const nsv)

sv_reset
Implementazione sottostante per la funzione Perl "reset". Si noti che il file perl-level
funzione è vagamente deprecata.

void sv_reset(const char* s, HV *const stash)

sv_rvweaken
Indebolisci un riferimento: imposta il flag "SvWEAKREF" su questo RV; dare la SV a cui si fa riferimento
magia "PERL_MAGIC_backref" se non l'ha già fatto; e spingi un riferimento all'indietro a questo
RV sulla serie di riferimenti a ritroso associati a quella magia. Se il camper è
magico, la magia del set verrà chiamata dopo che il camper sarà stato ripulito.

SV* sv_rvweaken(SV *const sv)

sv_setiv
Copia un numero intero nell'SV specificato, aggiornandolo prima se necessario. Non
gestire la magia "set". Vedi anche "sv_setiv_mg".

void sv_setiv(SV *const sv, const IV num)

sv_setiv_mg
Come "sv_setiv", ma gestisce anche la magia "set".

void sv_setiv_mg(SV *const sv, const IV i)

sv_setnv
Copia un double nel dato SV, aggiornandolo prima se necessario. Non gestisce
'imposta' la magia. Vedere anche "sv_setnv_mg".

void sv_setnv(SV *const sv, const NV num)

sv_setnv_mg
Come "sv_setnv", ma gestisce anche la magia "set".

void sv_setnv_mg(SV *const sv, const NV num)

sv_setpv
Copia una stringa in un SV. La stringa deve terminare con un carattere "NUL".
Non gestisce la magia "set". Vedere "sv_setpv_mg".

void sv_setpv(SV *const sv, const char *const ptr)

sv_setpvf
Funziona come "sv_catpvf" ma copia il testo nell'SV invece di aggiungerlo.
Non gestisce la magia "set". Vedere "sv_setpvf_mg".

void sv_setpvf(SV *const sv, const char *const pat,
...)

sv_setpvf_mg
Come "sv_setpvf", ma gestisce anche la magia "set".

void sv_setpvf_mg(SV *const sv,
const carattere *const pat, ...)

sv_setpviv
Copia un numero intero nell'SV dato, aggiornando anche il suo valore di stringa. Non
gestire la magia "set". Vedere "sv_setpviv_mg".

void sv_setpviv(SV *const sv, const IV num)

sv_setpviv_mg
Come "sv_setpviv", ma gestisce anche la magia "set".

void sv_setpviv_mg(SV *const sv, const IV iv)

sv_setpvn
Copia una stringa (possibilmente contenente caratteri "NUL" incorporati) in un SV. IL
Il parametro "len" indica il numero di byte da copiare. Se l'argomento "ptr".
è NULL l'SV diventerà indefinito. Non gestisce la magia "set". Vedere
"sv_setpvn_mg".

void sv_setpvn(SV *const sv, const char *const ptr,
cost STRLEN len)

sv_setpvn_mg
Come "sv_setpvn", ma gestisce anche la magia "set".

void sv_setpvn_mg(SV *const sv,
const carattere *const ptr,
cost STRLEN len)

sv_setpvs
Come "sv_setpvn", ma accetta una stringa letterale invece di una coppia stringa/lunghezza.

void sv_setpvs(SV* sv, const char* s)

sv_setpvs_mg
Come "sv_setpvn_mg", ma accetta una stringa letterale invece di una coppia stringa/lunghezza.

void sv_setpvs_mg(SV* sv, const char* s)

sv_setpv_mg
Come "sv_setpv", ma gestisce anche la magia "set".

void sv_setpv_mg(SV *const sv, const char *const ptr)

sv_setref_iv
Copia un numero intero in un nuovo SV, facoltativamente benedicendo lo SV. L'argomento "rv".
sarà aggiornato a un camper. Quel RV verrà modificato per puntare al nuovo SV. IL
L'argomento "classname" indica il pacchetto per la benedizione. Imposta "nomeclasse" su
"NULL" per evitare la benedizione. Il nuovo SV avrà un conteggio di riferimento di 1 e
il camper verrà restituito.

SV* sv_setref_iv(SV *const rv,
const char *const nomeclasse,
cost IV iv)

sv_setref_nv
Copia un doppio in una nuova SV, facoltativamente benedicendo la SV. L'argomento "rv" lo farà
essere aggiornato a un camper. Quel RV verrà modificato per puntare al nuovo SV. IL
L'argomento "classname" indica il pacchetto per la benedizione. Imposta "nomeclasse" su
"NULL" per evitare la benedizione. Il nuovo SV avrà un conteggio di riferimento di 1 e
il camper verrà restituito.

SV* sv_setref_nv(SV *const rv,
const char *const nomeclasse,
cost NV nv)

sv_setref_pv
Copia un puntatore in una nuova SV, opzionalmente benedicendo la SV. L'argomento "rv".
sarà aggiornato a un camper. Quel RV verrà modificato per puntare al nuovo SV. Se
l'argomento "pv" è NULL, quindi "PL_sv_undef" verrà inserito nell'SV. IL
L'argomento "classname" indica il pacchetto per la benedizione. Imposta "nomeclasse" su
"NULL" per evitare la benedizione. Il nuovo SV avrà un conteggio di riferimento di 1 e
il camper verrà restituito.

Non usare con altri tipi di Perl come HV, AV, SV, CV, perché quegli oggetti
verrà danneggiato dal processo di copia del puntatore.

Si noti che "sv_setref_pvn" copia la stringa mentre questo copia il puntatore.

SV* sv_setref_pv(SV *const rv,
const char *const nomeclasse,
vuoto *const pv)

sv_setref_pvn
Copia una stringa in un nuovo SV, facoltativamente benedicendo l'SV. La lunghezza del
la stringa deve essere specificata con "n". L'argomento "rv" verrà aggiornato a RV.
Quel RV verrà modificato per puntare al nuovo SV. L'argomento "classname".
indica il pacco per la benedizione. Imposta "classname" su "NULL" per evitare il
benedizione. Il nuovo SV avrà un conteggio di riferimento pari a 1 e il RV lo sarà
restituito.

Si noti che "sv_setref_pv" copia il puntatore mentre questo copia la stringa.

SV* sv_setref_pvn(SV *const rv,
const char *const nomeclasse,
const carattere *const pv,
cost STRLEN n)

sv_setref_pvs
Come "sv_setref_pvn", ma prende una stringa letterale invece di una coppia stringa/lunghezza.

SV * sv_setref_pvs(const char* s)

sv_setref_uv
Copia un intero senza segno in un nuovo SV, facoltativamente benedicendo l'SV. Il "camper"
argomento verrà aggiornato a un RV. Quel camper verrà modificato per puntare al nuovo
S.V. L'argomento "classname" indica il pacchetto per la benedizione. Impostato
"classname" su "NULL" per evitare la benedizione. Il nuovo SV avrà un riferimento
conteggio di 1 e il camper verrà restituito.

SV* sv_setref_uv(SV *const rv,
const char *const nomeclasse,
costante UV uv)

sv_setsv
Copia il contenuto dell'SV di origine "ssv" nell'SV di destinazione "dsv". IL
source SV può essere distrutto se è mortale, quindi non usare questa funzione se il
l'SV di origine deve essere riutilizzato. Non gestisce la magia "impostata" sull'SV di destinazione.
Chiama la magia 'get' sull'origine SV. In parole povere, esegue una copia per valore,
cancellando qualsiasi contenuto precedente della destinazione.

Probabilmente vorrai utilizzare uno dell'assortimento di wrapper, come "SvSetSV",
"SvSetSV_nosteal", "SvSetMagicSV" e "SvSetMagicSV_nosteal".

void sv_setsv(SV *dstr, SV *sstr)

sv_setsv_flags
Copia il contenuto dell'SV di origine "ssv" nell'SV di destinazione "dsv". IL
source SV può essere distrutto se è mortale, quindi non usare questa funzione se il
l'SV di origine deve essere riutilizzato. Non gestisce la magia "set". In parole povere, esso
esegue una copia per valore, cancellando qualsiasi contenuto precedente della destinazione.
Se il parametro "flags" ha il bit "SV_GMAGIC" impostato, verrà "mg_get" su "ssv" se
appropriato, altrimenti no. Se il parametro "flags" ha il bit "SV_NOSTEAL" impostato allora
i buffer dei temporanei non verranno rubati. e "sv_setsv_nomg" lo sono
implementato in termini di questa funzione.

Probabilmente vorrai utilizzare uno dell'assortimento di wrapper, come "SvSetSV",
"SvSetSV_nosteal", "SvSetMagicSV" e "SvSetMagicSV_nosteal".

Questa è la funzione principale per copiare scalari e la maggior parte delle altre operazioni di copia
le funzioni e le macro lo usano sotto.

void sv_setsv_flags(SV *dstr, SV *sstr,
cost I32 flag)

sv_setsv_mg
Come "sv_setsv", ma gestisce anche la magia 'set'.

void sv_setsv_mg(SV *const dstr, SV *const sstr)

sv_setuv
Copia un intero senza segno nel dato SV, aggiornandolo prima se necessario. Fa
non gestire la magia del "set". Vedi anche "sv_setuv_mg".

void sv_setuv(SV *const sv, const UV num)

sv_setuv_mg
Come "sv_setuv", ma gestisce anche la magia 'set'.

void sv_setuv_mg(SV *const sv, const UV u)

sv_contaminato
Testare un SV per la contaminazione. Utilizzare invece "SvTAINTED".

bool sv_contaminato(SV *const sv)

sv_true Restituisce vero se SV ha un valore vero secondo le regole di Perl. Utilizzare la macro "SvTRUE".
invece, che può chiamare "sv_true()" o può invece utilizzare una versione in linea.

I32 sv_true(SV *const sv)

sv_unmagic
Rimuove tutta la magia di tipo "tipo" da un SV.

int sv_unmagic(SV *const sv, const int tipo)

sv_unmagicext
Rimuove tutta la magia del tipo "tipo" con il "vtbl" specificato da un SV.

int sv_unmagicext(SV *const sv, const int tipo,
MGVTBL *vtbl)

sv_unref_flags
Disattiva lo stato RV dell'SV e decrementa il conteggio di riferimento di qualunque cosa fosse
essere referenziato dal RV. Questo può quasi essere pensato come un capovolgimento di
"nuovoSVrv". L'argomento "cflags" può contenere "SV_IMMEDIATE_UNREF" per forzare il file
conteggio dei riferimenti da decrementare (altrimenti il ​​decremento è condizionato a
il conteggio dei riferimenti è diverso da uno o il riferimento è di sola lettura
SV). Vedi "SvROK_off".

void sv_unref_flags(SV *const ref, const U32 flag)

sv_untaint
Incontamina un SV. Utilizzare invece "SvTAINTED_off".

void sv_untaint(SV *const sv)

sv_upgrade
Aggiorna un SV a una forma più complessa. Generalmente aggiunge un nuovo tipo di carrozzeria alla SV,
quindi copia quante più informazioni possibili dal vecchio corpo. Gracchia
se la SV è già in forma più complessa di quella richiesta. In genere lo desideri
utilizzare il wrapper macro "SvUPGRADE", che controlla il tipo prima di chiamare
"sv_upgrade", e quindi non gracchia. Vedi anche "svtype".

void sv_upgrade(SV *const sv, svtype nuovo_tipo)

sv_usepvn_flags
Dice a un SV di usare "ptr" per trovare il suo valore di stringa. Normalmente la stringa viene memorizzata
all'interno dell'SV, ma sv_usepvn consente all'SV di utilizzare una stringa esterna. Il "ptr"
dovrebbe puntare alla memoria allocata da Newx. Deve essere l'inizio di a
Blocco di memoria modificato e non un puntatore al centro di esso (attenzione a OOK e
copy-on-write) e non provenire da un allocatore di memoria non Newx come "malloc". IL
deve essere fornita la lunghezza della stringa, "len". Per impostazione predefinita questa funzione sarà "Rinnova"
(cioè realloc, sposta) la memoria puntata da "ptr", quindi quel puntatore non dovrebbe esserlo
liberato o utilizzato dal programmatore dopo averlo fornito a sv_usepvn, e nessuno dei due dovrebbe
qualsiasi puntatore da "dietro" quel puntatore (ad esempio ptr + 1) può essere utilizzato.

Se "flags" e SV_SMAGIC è vero, chiamerà SvSETMAGIC. Se "flag" &
SV_HAS_TRAILING_NUL è vero, quindi "ptr[len]" deve essere "NUL" e il realloc verrà
essere saltato (cioè il buffer è in realtà almeno 1 byte più lungo di "len", e
soddisfa già i requisiti per l'archiviazione in "SvPVX").

void sv_usepvn_flags(SV *const sv, char* ptr,
const STRLEN lente,
const bandiere U32)

sv_utf8_decode
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Se il PV dell'SV è una sequenza di ottetti in UTF-8 e contiene un byte multiplo
carattere, il flag "SvUTF8" viene attivato in modo che assomigli a un carattere. Se
il PV contiene solo caratteri a byte singolo, il flag "SvUTF8" rimane disattivato. Scansioni
PV per validità e restituisce false se il PV non è valido UTF-8.

bool sv_utf8_decode(SV *const sv)

sv_utf8_downgrade
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Tenta di convertire il PV di un SV da caratteri a byte. Se il PV contiene
un carattere che non può stare in un byte, questa conversione fallirà; in questo caso,
restituisce falso o, se "fail_ok" non è vero, gracchia.

Questa non è un'interfaccia di codifica da Unicode a byte di uso generale: utilizzare Encode
estensione per quello.

bool sv_utf8_downgrade(SV *const sv,
const bool fail_ok)

sv_utf8_encode
Converte il PV di un SV in UTF-8, ma poi disattiva il flag "SvUTF8" in modo che
sembra di nuovo ottetti.

void sv_utf8_encode(SV *const sv)

sv_utf8_upgrade
Converte il PV di un SV nel suo formato con codifica UTF-8. Forza l'SV in formato stringa
se non lo è già. Verrà "mg_get" su "sv" se appropriato. Imposta sempre il
Flag SvUTF8 per evitare futuri controlli di validità anche se l'intera stringa è la stessa
in UTF-8 come no. Restituisce il numero di byte nella stringa convertita

Questa non è una codifica byte di uso generale per l'interfaccia Unicode: utilizzare Encode
estensione per quello.

STRLEN sv_utf8_upgrade(SV *sv)

sv_utf8_upgrade_flags
Converte il PV di un SV nel suo formato con codifica UTF-8. Forza l'SV in formato stringa
se non lo è già. Imposta sempre il flag SvUTF8 per evitare futuri controlli di validità
anche se tutti i byte sono invarianti in UTF-8. Se "flags" ha il bit "SV_GMAGIC" impostato,
"mg_get" su "sv" se appropriato, altrimenti no.

Se "flags" ha SV_FORCE_UTF8_UPGRADE impostato, questa funzione presuppone che il PV
si espande quando viene convertito in UTF-8 e salta il lavoro aggiuntivo di verificarlo.
In genere questo flag viene utilizzato da una routine che ha già analizzato la stringa e
ha trovato tali personaggi e trasmette queste informazioni in modo che il lavoro non lo faccia
devono essere ripetuti.

Restituisce il numero di byte nella stringa convertita.

Questa non è una codifica byte di uso generale per l'interfaccia Unicode: utilizzare Encode
estensione per quello.

STRLEN sv_utf8_upgrade_flags(SV *const sv,
cost I32 flag)

sv_utf8_upgrade_flags_grow
Come sv_utf8_upgrade_flags, ma ha un parametro aggiuntivo "extra", che è il
numero di byte inutilizzati che la stringa 'sv' avrà sicuramente dopo di essa
ritorno. Ciò consente al chiamante di riservare spazio extra che intende riempire
evitare crescite extra.

"sv_utf8_upgrade", "sv_utf8_upgrade_nomg" e "sv_utf8_upgrade_flags" sono
implementato in termini di questa funzione.

Restituisce il numero di byte nella stringa convertita (esclusi gli spare).

STRLEN sv_utf8_upgrade_flags_grow(SV *const sv,
const I32 flag,
STRLEN extra)

sv_utf8_upgrade_nomg
Come sv_utf8_upgrade, ma non fa magie su "sv".

STRLEN sv_utf8_upgrade_nomg(SV *sv)

sv_vcatpvf
Elabora i suoi argomenti come "vsprintf" e aggiunge l'output formattato a un SV.
Non gestisce la magia "set". Vedi "sv_vcatpvf_mg".

Solitamente utilizzato tramite il suo frontend "sv_catpvf".

void sv_vcatpvf(SV *const sv, const char *const pat,
va_list *const argomenti)

sv_vcatpvfn
void sv_vcatpvfn(SV *const sv, const char *const pat,
const STRLEN patlen,
va_list *const argomenti,
SV **const svargs, const I32 svmax,
bool *const forse_contaminato)

sv_vcatpvfn_flags
Elabora i suoi argomenti come "vsprintf" e aggiunge l'output formattato a un SV.
Utilizza un array di SV se manca l'elenco degli argomenti delle variabili di stile C (NULL).
Quando viene eseguito con i controlli di contaminazione abilitati, indica tramite "forse_tainted" se i risultati
sono inaffidabili (spesso a causa dell'uso delle impostazioni locali).

Se chiamato come "sv_vcatpvfn" o i flag includono "SV_GMAGIC", le chiamate diventano magiche.

Solitamente utilizzato tramite uno dei suoi frontend "sv_vcatpvf" e "sv_vcatpvf_mg".

void sv_vcatpvfn_flags(SV *const sv,
const carattere *const pat,
const STRLEN patlen,
va_list *const argomenti,
SV **const svargs,
cost I32 svmax,
bool *const forse_contaminato,
const bandiere U32)

sv_vcatpvf_mg
Come "sv_vcatpvf", ma gestisce anche la magia 'set'.

Solitamente utilizzato tramite il suo frontend "sv_catpvf_mg".

void sv_vcatpvf_mg(SV *const sv,
const carattere *const pat,
va_list *const argomenti)

sv_vsetpvf
Funziona come "sv_vcatpvf" ma copia il testo nell'SV invece di aggiungerlo.
Non gestisce la magia "set". Vedi "sv_vsetpvf_mg".

Solitamente utilizzato tramite il suo frontend "sv_setpvf".

void sv_vsetpvf(SV *const sv, const char *const pat,
va_list *const argomenti)

sv_vsetpvfn
Funziona come "sv_vcatpvfn" ma copia il testo nell'SV invece di aggiungerlo.

Solitamente utilizzato tramite uno dei suoi frontend "sv_vsetpvf" e "sv_vsetpvf_mg".

void sv_vsetpvfn(SV *const sv, const char *const pat,
const STRLEN patlen,
va_list *const argomenti,
SV **const svargs, const I32 svmax,
bool *const forse_contaminato)

sv_vsetpvf_mg
Come "sv_vsetpvf", ma gestisce anche la magia 'set'.

Solitamente utilizzato tramite il suo frontend "sv_setpvf_mg".

void sv_vsetpvf_mg(SV *const sv,
const carattere *const pat,
va_list *const argomenti)

Unicode Assistenza

"Supporto Unicode" in perlguts ha un'introduzione a questa API.

Vedi anche "Classificazione dei caratteri" e "Cambiamento delle maiuscole e minuscole dei caratteri". Varie funzioni
al di fuori di questa sezione funzionano soprattutto con Unicode. Cerca la stringa "utf8" in
questo documento.

bytes_cmp_utf8
Confronta la sequenza di caratteri (memorizzati come ottetti) in "b", "blen" con il file
sequenza di caratteri (memorizzata come UTF-8) in "u", "ulen". Restituisce 0 se lo sono
uguale, -1 o -2 se la prima stringa è minore della seconda stringa, +1 o +2 se
la prima stringa è maggiore della seconda stringa.

-1 o +1 viene restituito se la stringa più breve era identica all'inizio del file
corda più lunga. -2 o +2 vengono restituiti se c'era una differenza tra i caratteri
all'interno delle corde.

int bytes_cmp_utf8(const U8 *b, STRLEN blen,
const U8 *u, STRLEN ulen)

byte_da_utf8
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Converte una stringa "s" di lunghezza "len" da UTF-8 nella codifica byte nativa.
A differenza di "utf8_to_bytes" ma come "bytes_to_utf8", restituisce un puntatore al nuovo-
stringa creata e aggiorna "len" per contenere la nuova lunghezza. Restituisce l'originale
stringa se non avviene alcuna conversione, "len" rimane invariato. Non fare nulla se "is_utf8"
punta a 0. Imposta "is_utf8" a 0 se "s" è convertito o consiste interamente di
caratteri che sono invarianti in utf8 (ad esempio, US-ASCII su macchine non EBCDIC).

U8* bytes_from_utf8(const U8 *s, STRLEN *len,
bool *is_utf8)

byte_in_utf8
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Converte una stringa "s" di lunghezza "len" byte dalla codifica nativa in UTF-8.
Restituisce un puntatore alla stringa appena creata e imposta "len" per riflettere la nuova
lunghezza in byte.

Verrà scritto un carattere "NUL" dopo la fine della stringa.

Se desideri convertire in UTF-8 da codifiche diverse da quella nativa (Latin1 o
EBCDIC), vedere "sv_recode_to_utf8"().

U8* bytes_to_utf8(const U8 *s, STRLEN *len)

DO_UTF8 Restituisce un valore booleano che indica se il PV in "sv" deve essere trattato come tale
codificato in UTF-8.

Dovresti usare questo dopo una chiamata a "SvPV()" o una delle sue varianti, se presente
la chiamata all'overloading delle stringhe aggiorna il flag di codifica UTF-8 interno.

bool DO_UTF8(SV* sv)

foldEQ_utf8
Restituisce vero se le parti iniziali delle stringhe "s1" e "s2" (una o entrambe
di cui può essere in UTF-8) sono gli stessi senza distinzione tra maiuscole e minuscole; falso altrimenti. Come
la distanza tra le stringhe da confrontare è determinata da altri parametri di input.

Se "u1" è vero, si presuppone che la stringa "s1" sia in Unicode con codifica UTF-8;
altrimenti si presuppone che sia nella codifica nativa a 8 bit. Corrispondente a "u2"
rispetto a "s2".

Se la lunghezza del byte "l1" è diversa da zero, indica quanto lontano in "s1" deve essere verificato il piegamento
uguaglianza. In altre parole, "s1"+"l1" verrà utilizzato come obiettivo da raggiungere. La scansione
non sarà considerata una partita a meno che l'obiettivo non venga raggiunto e scansionato
non continuerà oltre quell'obiettivo. Corrispondentemente per "l2" rispetto a "s2".

Se "pe1" è diverso da NULL e il puntatore a cui punta non è NULL, quel puntatore lo è
considerato un puntatore finale alla posizione 1 byte oltre il punto massimo in "s1"
oltre il quale la scansione non proseguirà in nessun caso. (Questa routine
presuppone che le stringhe di input codificate UTF-8 non siano malformate; input non valido può
farlo leggere oltre "pe1"). Ciò significa che se sia "l1" che "pe1" lo sono
specificato e "pe1" è minore di "s1"+"l1", la corrispondenza non avrà mai successo
perché non potrà mai arrivare al suo obiettivo (e infatti viene contrastato).
Corrispondentemente per "pe2" rispetto a "s2".

Almeno uno tra "s1" e "s2" deve avere un obiettivo (almeno uno tra "l1" e "l2" deve
essere diverso da zero) e se lo fanno entrambi, affinché la corrispondenza abbia successo è necessario raggiungerli entrambi.
Inoltre, se la piega di un personaggio è composta da più caratteri, devono esserlo tutti
abbinato (vedi riferimento tr21 di seguito per 'folding').

In caso di corrispondenza riuscita, se "pe1" è diverso da NULL, verrà impostato per puntare a
inizio del GENERAZIONE carattere di "s1" oltre quello corrispondente. Di conseguenza
per "pe2" e "s2".

Per la distinzione tra maiuscole e minuscole, al posto di viene utilizzato il "casefolding" di Unicode
maiuscolo/minuscolo entrambi i caratteri, vedi
<http://www.unicode.org/unicode/reports/tr21/> (Mappature dei casi).

I32 foldEQ_utf8(const carattere *s1, carattere **pe1, UV l1,
bool u1, const char *s2, char **pe2,
UV l2, bool u2)

èUTF8_CHAR
Restituisce il numero di byte che iniziano con "s" che formano un UTF-8 legale (o UTF-
EBCDIC) carattere codificato, cercando solo i byte "e - s" in "s".
Restituisce 0 se la sequenza che inizia da "s" fino a "e - 1" non ha un formato UTF-8 corretto

Tieni presente che un carattere INVARIANTE (ovvero ASCII su macchine non EBCDIC) è valido
Carattere UTF-8.

STRLEN èUTF8_CHAR(const U8 *s, const U8 *e)

is_ascii_string
Questo è un sinonimo dal nome fuorviante per "is_invariant_string". In stile ASCII
piattaforme, il nome non è fuorviante: i caratteri dell'intervallo ASCII sono esattamente i
Invarianti UTF-8. Ma le macchine EBCDIC hanno più invarianti oltre al solo ASCII
caratteri, quindi è preferibile "is_invariant_string".

bool is_ascii_string(const U8 *s, STRLEN len)

è_stringa_invariante
Restituisce vero se e solo se i primi byte "len" della stringa "s" sono gli stessi a prescindere
della codifica UTF-8 della stringa (o codifica UTF-EBCDIC su macchine EBCDIC).
Cioè, se sono invarianti UTF-8. Sulle macchine ASCII, tutti i file ASCII
caratteri e solo i caratteri ASCII soddisfano questa definizione. Sulle macchine EBCDIC,
i caratteri dell'intervallo ASCII sono invarianti, ma lo sono anche i controlli C1 e
"\C?" (che non è nell'intervallo ASCII su EBCDIC).

Se "len" è 0, verrà calcolato utilizzando strlen(s), (il che significa che se usi this
opzione, quella "s" non può contenere caratteri "NUL" incorporati e deve avere un
byte "NUL" finale).

Vedi anche "is_utf8_string"(), "is_utf8_string_loclen"() e
"is_utf8_string_loc"().

bool is_invariant_string(const U8 *s, STRLEN len)

is_utf8_string
Restituisce vero se i primi byte "len" della stringa "s" formano una stringa UTF-8 valida,
falso altrimenti. Se "len" è 0, verrà calcolato utilizzando strlen(s) (che
significa che se usi questa opzione, la "s" non può contenere caratteri "NUL" incorporati e
deve avere un byte finale "NUL"). Tieni presente che tutti i caratteri sono ASCII
costituiscono "una stringa UTF-8 valida".

Vedi anche "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
Come "is_utf8_string" ma memorizza la posizione dell'errore (nel caso di
"utf8ness Failure") o la posizione "s"+"len" (nel caso di "utf8ness success")
nell'"ep".

Vedi anche "is_utf8_string_loclen"() e "is_utf8_string"().

bool is_utf8_string_loc(const U8 *s, STRLEN len,
cost U8 **ep)

is_utf8_string_loclen
Come "is_utf8_string"() ma memorizza la posizione dell'errore (nel caso di
"utf8ness Failure") o la posizione "s"+"len" (nel caso di "utf8ness success")
in "ep" e il numero di caratteri codificati UTF-8 in "el".

Vedi anche "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
Costruisci nello scalare "dsv" una versione visualizzabile della stringa "spv", lunghezza "len",
la versione visualizzabile è lunga al massimo "pvlim" byte (se più lunga, il resto lo è
troncato e verrà aggiunto "...".

L'argomento "flags" può avere UNI_DISPLAY_ISPRINT impostato su display èPRINT()in grado di
caratteri come se stessi, UNI_DISPLAY_BACKSLASH per visualizzare \\[nrfta\\] come
versioni con barra rovesciata (come '\n') (UNI_DISPLAY_BACKSLASH è preferibile a
UNI_DISPLAY_ISPRINT per \\). UNI_DISPLAY_QQ (e il suo alias UNI_DISPLAY_REGEX)
avere sia UNI_DISPLAY_BACKSLASH che UNI_DISPLAY_ISPRINT attivati.

Viene restituito il puntatore al PV del "dsv".

Vedi anche "sv_uni_display".

char* pv_uni_display(SV *dsv, const U8 *spv,
STRLEN lente, STRLEN pvlim,
bandiere UV)

sv_cat_decode
Si presuppone che la codifica sia un oggetto Encode, si presuppone che lo sia il PV di ssv
ottetti in quanto la codifica e decodifica dell'ingresso inizia dalla posizione che (PV
+ *offset) indicato. Nel dsv verrà concatenata la stringa UTF-8 decodificata
ssv. La decodifica terminerà quando la stringa tstr apparirà nell'output della decodifica o
l'ingresso termina sul PV dell'ssv. Il valore che saranno i punti di offset
modificato nell'ultima posizione di input su ssv.

Restituisce VERO se è stato trovato il terminatore, altrimenti restituisce FALSO.

bool sv_cat_decode(SV* dsv, SV *codifica, SV *ssv,
int *offset, char* tstr, int tlen)

sv_recode_to_utf8
Si presuppone che la codifica sia un oggetto Encode, all'ingresso lo è il PV di sv
si presume che siano ottetti in quella codifica e sv verrà convertito in Unicode
(e UTF-8).

Se l'sv è già UTF-8 (o se non è POK), o se la codifica non è a
riferimento, non viene fatto nulla al sv. Se la codifica non è "Codifica::XS"
Codifica l'oggetto, accadranno cose brutte. (Vedere lib/encoding.pm e codifica.)

Viene restituito il PV della sv.

char* sv_recode_to_utf8(SV* sv, SV *codifica)

sv_uni_display
Costruisci nello scalare "dsv" una versione visualizzabile dello scalare "sv", il file
versione visualizzabile lunga al massimo "pvlim" byte (se più lunga, il resto è
troncato e verrà aggiunto "...".

L'argomento "flags" è come in "pv_uni_display"().

Viene restituito il puntatore al PV del "dsv".

char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim,
bandiere UV)

to_utf8_case
"p" contiene il puntatore alla stringa UTF-8 che codifica il carattere in corso
convertito. Questa routine presuppone che il carattere in "p" sia ben formato.

"ustrp" è un puntatore al buffer dei caratteri in cui inserire il risultato della conversione.
"lenp" è un puntatore alla lunghezza del risultato.

"swashp" è un puntatore allo swash da utilizzare.

Sono memorizzate sia la mappatura speciale che quella normale lib/unicore/To/Foo.pl e
caricato da SWASHNEW, utilizzando lib/utf8_heavy.pl. "speciale" (di solito, ma non sempre,
una mappatura multicarattere), viene provato per primo.

"special" è una stringa, normalmente "NULL" o "". "NULL" significa non utilizzare nessuno speciale
mappature; "" significa utilizzare le mappature speciali. Valori diversi da questi due lo sono
trattato come il nome dell'hash contenente le mappature speciali, come
"utf8::ToSpecLower".

"normal" è una stringa come "ToLower" che significa lo swash %utf8::ToLower.

UV to_utf8_case(const U8 *p, U8* ustrp,
STRLEN *lenp, SV **swashp,
const carattere *normale,
const carattere *speciale)

to_utf8_fold
Utilizza invece "toFOLD_utf8".

UV to_utf8_fold(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_lower
Utilizzare invece "toLOWER_utf8".

UV to_utf8_lower(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_title
Utilizzare invece "toTITLE_utf8".

UV to_utf8_title(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_upper
Utilizzare invece "toUPPER_utf8".

UV to_utf8_upper(const U8 *p, U8* ustrp,
STRLEN *lenp)

utf8n_to_uvchr
QUESTA FUNZIONE DEVE ESSERE UTILIZZATA SOLO IN CIRCOSTANZE MOLTO SPECIALIZZATE. La maggior parte del codice
dovrebbe usare "utf8_to_uvchr_buf"() invece di chiamarlo direttamente.

Routine di decodifica UTF-8 di livello inferiore. Restituisce il valore del punto di codice nativo di
primo carattere nella stringa "s", che si presuppone sia in UTF-8 (o UTF-EBCDIC)
codifica e non più lunga di byte "arricciati"; *retlen (se "retlen" non è NULL) lo farà
essere impostato sulla lunghezza, in byte, di quel carattere.

Il valore di "flags" determina il comportamento quando "s" non punta a una posizione ben
formato un carattere UTF-8. Se "flags" è 0, quando viene rilevata una malformazione, lo è zero
restituito e *retlen è impostato in modo che ("s" + *retlen) sia la successiva posizione possibile
in "s" che potrebbe iniziare con un carattere non malformato. Inoltre, se gli avvisi UTF-8
non sono stati disabilitati lessicalmente, viene generato un avviso.

È possibile impostare vari flag ALLOW in "flag" per consentire (e non avvisare) i singoli utenti
tipi di malformazioni, come la sequenza troppo lunga (cioè quando c'è
è una sequenza più breve che può esprimere lo stesso punto di codice; le sequenze troppo lunghe lo sono
espressamente vietato nello standard UTF-8 a causa di potenziali problemi di sicurezza).
Un altro esempio di malformazione è il primo byte di un carattere che non è legale
primo byte. Vedere utf8.h per l'elenco di tali flag. Per le stringhe consentite di lunghezza 0,
questa funzione restituisce 0; per le sequenze troppo lunghe consentite, il punto di codice calcolato
viene restituito; per tutte le altre malformazioni consentite, la SOSTITUZIONE Unicode
Viene restituito CARATTERE, poiché questi non hanno un valore ragionevole determinabile.

Il flag UTF8_CHECK_ONLY sovrascrive il comportamento quando un file non consentito (da altri
flags) viene rilevata una malformazione. Se questo flag è impostato, la routine presuppone che il file
il chiamante genererà un avviso e questa funzione imposterà silenziosamente semplicemente "retlen" su
"-1" (trasmesso a "STRLEN") e restituisce zero.

Tieni presente che questa API richiede la disambiguazione tra la decodifica riuscita di un "NUL"
carattere e un ritorno di errore (a meno che non sia impostato il flag UTF8_CHECK_ONLY), come in
in entrambi i casi viene restituito 0. Per chiarire le ambiguità, in caso di rendimento pari a zero, vedere se il primo
anche il byte di "s" è 0. Se è così, l'input era un "NUL"; in caso contrario, l'input aveva un file
errore.

Alcuni punti di codice sono considerati problematici. Questi sono surrogati Unicode,
Non caratteri Unicode e punti di codice superiori al massimo Unicode di 0x10FFFF. Di
per impostazione predefinita questi sono considerati punti di codice regolari, ma determinate situazioni lo giustificano
trattamento speciale per loro. Se "flag" contiene UTF8_DISALLOW_ILLEGAL_INTERCHANGE,
tutte e tre le classi vengono trattate come malformazioni e gestite come tali. Le bandiere
UTF8_DISALLOW_SURROGATE, UTF8_DISALLOW_NONCHAR e UTF8_DISALLOW_SUPER (che significa
sopra il massimo legale Unicode) può essere impostato per non consentire queste categorie
individualmente.

I flag UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, UTF8_WARN_NONCHAR,
e UTF8_WARN_SUPER causeranno la generazione di messaggi di avviso per i rispettivi
categorie, ma per il resto i punti codice sono considerati validi (not
malformazioni). Per ottenere che una categoria sia trattata come una malformazione e sia sollevata
un avviso, specificare entrambi i flag WARN e DISALLOW. (Ma nota che gli avvertimenti sono
non sollevato se lessicalmente disabilitato né se è specificato anche UTF8_CHECK_ONLY.)

I punti di codice molto grandi (sopra 0x7FFF_FFFF) sono considerati più problematici di
gli altri che sono al di sopra del massimo legale Unicode. Ci sono diversi motivi:
richiedono almeno 32 bit per rappresentarli su piattaforme ASCII, non lo sono
rappresentabile in alcun modo sulle piattaforme EBCDIC e sulla specifica UTF-8 originale
non è mai andato oltre questo numero (l'attuale limite 0x10FFFF è stato imposto successivamente). (IL
quelli più piccoli, quelli che stanno in 32 bit, sono rappresentabili da un UV su ASCII
piattaforme, ma non da un IV, il che significa che il numero di operazioni che possono essere
eseguita su di essi è piuttosto limitata.) La codifica UTF-8 su piattaforme ASCII per
questi punti di codice di grandi dimensioni iniziano con un byte contenente 0xFE o 0xFF. IL
Il flag UTF8_DISALLOW_FE_FF farà sì che vengano trattati come malformazioni, mentre
consentendo punti di codice superiori a Unicode più piccoli. (Ovviamente UTF8_DISALLOW_SUPER lo farà
trattare tutti i punti di codice sopra Unicode, compresi questi, come malformazioni.)
Allo stesso modo, UTF8_WARN_FE_FF agisce esattamente come gli altri flag WARN, ma si applica semplicemente
a questi punti di codice.

Tutti gli altri punti di codice corrispondenti ai caratteri Unicode, compreso l'uso privato
e quelli ancora da assegnare, non vengono mai considerati malformati e non vengono mai avvisati.

UV utf8n_to_uvchr(const U8 *s, STRLEN curlen,
STRLEN *retlen, bandiere U32)

utf8n_to_uvuni
Utilizzare invece "utf8_to_uvchr_buf", o raramente "utf8n_to_uvchr".

Questa funzione era utile per il codice che voleva gestire sia EBCDIC che ASCII
piattaforme con proprietà Unicode, ma a partire da Perl v5.20, le distinzioni
tra le piattaforme sono stati per lo più resi invisibili alla maggior parte del codice, quindi questo
è abbastanza improbabile che la funzione sia quella desiderata. Se hai bisogno di questo preciso
funzionalità, utilizzare invece "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" o
"NATIVE_TO_UNI(utf8n_to_uvchr(...))".

UV utf8n_to_uvuni(const U8 *s, STRLEN curlen,
STRLEN *retlen, bandiere U32)

UTF8SKIP
restituisce il numero di byte nel carattere codificato UTF-8 il cui primo (forse
solo) il byte è indicato da "s".

STRLEN UTF8SKIP(carattere* s)

utf8_distanza
Restituisce il numero di caratteri UTF-8 compresi tra i puntatori UTF-8 "a" e "b".

ATTENZIONE: utilizzare solo se si *sai* che i puntatori puntano all'interno dello stesso UTF-8
tampone.

IV utf8_distanza(cost U8 *a, cost U8 *b)

utf8_hop
Restituisce il puntatore UTF-8 "s" sostituito dai caratteri "off", in avanti o
indietro.

ATTENZIONE: non utilizzare quanto segue a meno che *non si sappia* che "off" è compreso nei dati UTF-8
indicato da "s" *e* che la voce "s" è allineata al primo byte di
carattere o subito dopo l'ultimo byte di un carattere.

U8* utf8_hop(const U8 *s, I32 disattivato)

utf8_lunghezza
Restituisce la lunghezza della stringa "s" con codifica carattere UTF-8 in caratteri. Si ferma a
"e" (compreso). Se "e < s" o se la scansione finisce oltre "e", gracchia.

STRLEN utf8_length(const U8* s, const U8 *e)

utf8_in_byte
NOTA: questa funzione è sperimentale e può cambiare o essere rimossa senza preavviso.

Converte una stringa "s" di lunghezza "len" da UTF-8 nella codifica byte nativa.
A differenza di "bytes_to_utf8", questo sovrascrive la stringa originale e aggiorna "len" in
contenere la nuova lunghezza. Restituisce zero in caso di fallimento, impostando "len" su -1.

Se hai bisogno di una copia della stringa, vedi "bytes_from_utf8".

U8* utf8_to_bytes(U8 *s, STRLEN *len)

utf8_to_uvchr_buf
Restituisce il punto di codice nativo del primo carattere nella stringa "s" che è
si presume che sia nella codifica UTF-8; "send" punta a 1 oltre la fine della "s".
*retlen verrà impostato sulla lunghezza, in byte, di quel carattere.

Se "s" non punta a un carattere UTF-8 ben formato e gli avvisi UTF8 lo sono
abilitato, viene restituito zero e *retlen è impostato (se "retlen" non è NULL) su -1. Se
tali avvisi sono disattivati, il valore calcolato, se ben definito (o il valore Unicode
CARATTERE DI SOSTITUZIONE in caso contrario), viene restituito in modo silenzioso e viene impostato *retlen (se
"retlen" non è NULL) quindi ("s" + *retlen) è la prossima posizione possibile in "s"
che potrebbe iniziare un carattere non malformato. Vedere "utf8n_to_uvchr" per i dettagli su
quando viene restituito il CARATTERE DI SOSTITUZIONE.

UV utf8_to_uvchr_buf(const U8 *s, const U8 *invia,
STRLEN *retlen)

utf8_to_uvuni_buf
DEPRECATO! Si prevede di rimuovere questa funzione da una futura versione di Perl.
Non usarlo per il nuovo codice; rimuoverlo dal codice esistente.

Solo in circostanze molto rare il codice dovrebbe dover gestire Unicode (come
al contrario dei punti di codice nativi). In quei pochi casi, utilizzare
"NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" invece.

Restituisce il punto di codice Unicode (non nativo) del primo carattere nella stringa
"s" che si presuppone sia nella codifica UTF-8; "invia" punta a 1 oltre la fine di
"S". "retlen" verrà impostato sulla lunghezza, in byte, di quel carattere.

Se "s" non punta a un carattere UTF-8 ben formato e gli avvisi UTF8 lo sono
abilitato, viene restituito zero e *retlen è impostato (se "retlen" non è NULL) su -1. Se
quegli avvisi sono disattivati, il valore calcolato se ben definito (o Unicode
CARATTERE DI SOSTITUZIONE, in caso contrario) viene restituito silenziosamente e viene impostato *retlen (se
"retlen" non è NULL) quindi ("s" + *retlen) è la prossima posizione possibile in "s"
che potrebbe iniziare un carattere non malformato. Vedere "utf8n_to_uvchr" per i dettagli su
quando viene restituito il CARATTERE DI SOSTITUZIONE.

UV utf8_to_uvuni_buf(const U8 *s, const U8 *invia,
STRLEN *retlen)

UVCHR_SKIP
restituisce il numero di byte richiesti per rappresentare il punto di codice "cp" quando codificato
come UTF-8. "cp" è un punto di codice nativo (ASCII o EBCDIC) se inferiore a 255; UN
Punto di codice Unicode altrimenti.

STRLEN UVCHR_SKIP(UV cp)

uvchr_to_utf8
Aggiunge la rappresentazione UTF-8 del punto di codice nativo "uv" alla fine del file
stringa "d"; "d" dovrebbe avere almeno "UVCHR_SKIP(uv)+1" (fino a "UTF8_MAXBYTES+1")
byte liberi disponibili. Il valore restituito è il puntatore al byte dopo la fine
del nuovo personaggio. In altre parole,

d = uvchr_to_utf8(d, uv);

è il modo di dire consigliato, ampio e consapevole del carattere nativo

*(d++) = uv;

Questa funzione accetta qualsiasi UV come input. Per vietare o avvisare su codice non Unicode
punti, o quelli che potrebbero essere problematici, vedere "uvchr_to_utf8_flags".

U8* uvchr_to_utf8(U8 *d, UV uv)

uvchr_to_utf8_flags
Aggiunge la rappresentazione UTF-8 del punto di codice nativo "uv" alla fine del file
stringa "d"; "d" dovrebbe avere almeno "UVCHR_SKIP(uv)+1" (fino a "UTF8_MAXBYTES+1")
byte liberi disponibili. Il valore restituito è il puntatore al byte dopo la fine
del nuovo personaggio. In altre parole,

d = uvchr_to_utf8_flags(d, uv, flags);

o, nella maggior parte dei casi,

d = uvchr_to_utf8_flags(d, uv, 0);

Questo è il modo di dire compatibile con Unicode

*(d++) = uv;

Questa funzione convertirà in UTF-8 (e non avviserà) anche i punti di codice che non lo sono
Unicode legale o sono problematici, a meno che "flag" non contenga uno o più dei file
seguenti bandiere:

Se "uv" è un punto di codice surrogato Unicode ed è impostato UNICODE_WARN_SURROGATE,
la funzione genererà un avviso, a condizione che gli avvisi UTF8 siano abilitati. Se invece
UNICODE_DISALLOW_SURROGATE è impostato, la funzione fallirà e restituirà NULL. Se
entrambi i flag sono impostati, la funzione avviserà e restituirà NULL.

I flag UNICODE_WARN_NONCHAR e UNICODE_DISALLOW_NONCHAR influiscono sul modo in cui
la funzione gestisce un non carattere Unicode. E allo stesso modo, UNICODE_WARN_SUPER
e UNICODE_DISALLOW_SUPER influiscono sulla gestione dei punti di codice sopra
il massimo Unicode di 0x10FFFF. I punti di codice superiori a 0x7FFF_FFFF (che sono pari
meno portabile) può essere avvisato e/o non consentito anche se si tratta di un altro codice sopra Unicode
i punti sono accettati dai flag UNICODE_WARN_FE_FF e UNICODE_DISALLOW_FE_FF.

E infine, il flag UNICODE_WARN_ILLEGAL_INTERCHANGE seleziona tutti e quattro i file
sopra i flag WARN; e UNICODE_DISALLOW_ILLEGAL_INTERCHANGE li seleziona tutti e quattro
Flag NON CONSENTITI.

U8* uvchr_to_utf8_flags(U8 *d, UV uv, flag UV)

uvoffuni_to_utf8_flags
QUESTA FUNZIONE DEVE ESSERE UTILIZZATA SOLO IN CIRCOSTANZE MOLTO SPECIALIZZATE. Invece,
Quasi contro tutti i codice dovrebbero uso "uvchr_to_utf8" or "uvchr_to_utf8_flags".

Questa funzione è simile a queste, ma l'input è un Unicode rigoroso (al contrario di
nativo) punto di codice. Solo in circostanze molto rare il codice non dovrebbe utilizzare il file
punto di codice nativo.

Per i dettagli, vedere la descrizione di "uvchr_to_utf8_flags".

U8* uvoffuni_to_utf8_flags(U8 *d, UV uv, bandiere UV)

uvuni_to_utf8_flags
Invece quasi sicuramente vorrai usare "uvchr_to_utf8" o "uvchr_to_utf8_flags".

Questa funzione è un sinonimo deprecato di "uvoffuni_to_utf8_flags", che a sua volta,
sebbene non sia deprecato, dovrebbe essere utilizzato solo in circostanze isolate. Questi
le funzioni erano utili per il codice che voleva gestire sia EBCDIC che ASCII
piattaforme con proprietà Unicode, ma a partire da Perl v5.20, le distinzioni
tra le piattaforme sono stati per lo più resi invisibili alla maggior parte del codice, quindi questo
è abbastanza improbabile che la funzione sia quella desiderata.

U8* uvuni_to_utf8_flags(U8 *d, UV uv, bandiere UV)

Variabili creato by "xsubpp" e a "xsubpp" interno funzioni

nuovoXSproto
Utilizzato da "xsubpp" per collegare XSUB come sottotitoli Perl. Aggiunge prototipi Perl ai sottotitoli.

XS_APIVERSION_BOOTCHECK
Macro per verificare che la versione dell'API Perl rispetto alla quale sia stato compilato un modulo XS
corrisponde alla versione API dell'interprete Perl in cui viene caricato.

XS_APIVERSION_BOOTCHECK;

XS_VERSIONE
L'identificatore della versione per un modulo XS. Questo di solito viene gestito automaticamente da
"ExtUtils::MakeMaker". Vedere "XS_VERSION_BOOTCHECK".

XS_VERSION_BOOTCHECK
Macro per verificare che la variabile $VERSION di un modulo PM corrisponda a quella del modulo XS
Variabile "XS_VERSION". Questo di solito viene gestito automaticamente da "xsubpp". Vedere
"Il VERSIONCHECK: parola chiave" in perlxs.

XS_VERSION_BOOTCHECK;

versioning

nuova versione
Restituisce un nuovo oggetto versione in base al passato in SV:

SV *sv = nuova_versione(SV *ver);

Non altera quanto passato nella ver SV. Vedi "upg_version" se vuoi aggiornare il
SV.

SV* nuova_versione(SV *ver)

versione_prescansione
Convalida che una determinata stringa può essere analizzata come oggetto versione, ma non lo fa
effettivamente eseguire l'analisi. È possibile utilizzare regole di convalida rigide o permissive. Potere
opzionalmente imposta un numero di variabili di suggerimento per salvare il codice di analisi in un determinato momento
tokenizzazione.

const char* prescan_version(const char *s, bool strict,
const carattere** errstr,
booleano *sqv,
int *ssaw_decimal,
int *larghezza, bool *salpha)

scansione_versione
Restituisce anche un puntatore al carattere successivo dopo la stringa della versione analizzata
come l'aggiornamento del passato in SV a un camper.

La funzione deve essere chiamata con un SV già esistente

sv = nuovoSV(0);
s = scan_version(s, SV *sv, bool qv);

Esegue alcune operazioni di preelaborazione sulla stringa per garantire che abbia il valore corretto
caratteristiche di una versione Contrassegna l'oggetto se contiene un carattere di sottolineatura
(che denota che questa è una versione alpha). Il valore booleano qv indica che la versione
dovrebbe essere interpretato come se avesse più decimali, anche se non è così.

const char* scan_version(const char *s, SV *rv, bool qv)

upg_version
Aggiornamento sul posto dell'SV fornito a un oggetto versione.

SV *sv = upg_versione(SV *sv, bool qv);

Restituisce un puntatore all'SV aggiornato. Imposta il valore booleano qv se vuoi forzare
questa SV è da interpretarsi come una versione “estesa”.

SV* upg_version(SV *ver, bool qv)

vcmp Versione con riconoscimento dell'oggetto cmp. Entrambi gli operandi devono essere già stati convertiti in
oggetti di versione.

int vcmp(SV *lhv, SV *rhv)

vnormal Accetta un oggetto versione e restituisce la rappresentazione della stringa normalizzata. Chiamata
piace:

sv = vnormal(rv);

NOTA: è possibile passare direttamente l'oggetto oppure la SV contenuta all'interno della RV.

L'SV restituito ha un conteggio pari a 1.

SV* vnormal(SV *vs)

vnumify Accetta un oggetto versione e restituisce la rappresentazione in virgola mobile normalizzata.
Chiama come:

sv = vnumifica(rv);

NOTA: è possibile passare direttamente l'oggetto oppure la SV contenuta all'interno della RV.

L'SV restituito ha un conteggio pari a 1.

SV* vnumifica(SV *vs)

vstringify
Per mantenere la massima compatibilità con le versioni precedenti di Perl, questo
la funzione restituirà la notazione in virgola mobile o il multiplo puntato
notazione, a seconda che la versione originale contenga 1 o più punti,
rispettivamente.

L'SV restituito ha un conteggio pari a 1.

SV* vstringifica(SV *vs)

vverify Verifica che SV contenga una struttura interna valida per un oggetto versione. Esso
può essere passato l'oggetto versione (RV) o l'hash stesso (HV). Se la
la struttura è valida, restituisce l'HV. Se la struttura non è valida, ritorna
NULLO.

SV *hv = vverifica(sv);

Si noti che conferma solo la struttura minima (per non confondersi
da classi derivate che possono contenere voci hash aggiuntive):

SV* vverifica(SV *vs)

Avvertenza e a Morire

croak Questa è un'interfaccia XS per la funzione "die" di Perl.

Prendi un modello di formato e un elenco di argomenti in stile sprintf. Questi sono usati per generare
un messaggio di stringa. Se il messaggio non termina con una nuova riga, lo sarà
esteso con qualche indicazione della posizione attuale nel codice, come descritto
per "mess_sv".

Il messaggio di errore verrà utilizzato come eccezione, restituendo il controllo a
il "eval" più vicino che lo racchiude, ma soggetto a modifica da parte di un $SIG{__DIE__}
gestore. In ogni caso la funzione "croak" non ritorna mai normalmente.

Per ragioni storiche, se "pat" è nullo, lo sarà anche il contenuto di "ERRSV" ($@).
utilizzato come messaggio di errore o oggetto invece di creare un messaggio di errore da
argomenti. Se vuoi lanciare un oggetto non stringa o creare un messaggio di errore in
un SV, è preferibile utilizzare la funzione "croak_sv", che non lo fa
implicano la distruzione di "ERRSV".

void croak(const char *pat, ...)

croak_no_modify
Esattamente equivalente a "Perl_croak(aTHX_ "%s", PL_no_modify)", ma genera conciso
codice oggetto piuttosto che usare "Perl_croak". Meno codice utilizzato nei percorsi del codice di eccezione
riduce la pressione della cache della CPU.

void croak_no_modify()

gracchiare_sv
Questa è un'interfaccia XS per la funzione "die" di Perl.

"baseex" è il messaggio di errore o l'oggetto. Se è un riferimento, verrà utilizzato
come è. Altrimenti viene utilizzato come stringa e se non termina con un ritorno a capo
poi verrà esteso con qualche indicazione della posizione attuale nel codice,
come descritto per "mess_sv".

Il messaggio di errore o l'oggetto verrà utilizzato come eccezione e verrà restituito per impostazione predefinita
controllo al "eval" più vicino che lo racchiude, ma soggetto a modifica da parte di a
Gestore $SIG{__DIE__}. In ogni caso, la funzione "croak_sv" non ritorna mai
normalmente.

Per morire con un semplice messaggio di stringa, la funzione "gracchia" può essere più comoda.

void croak_sv(SV *baseex)

die Si comporta come "croak", ad eccezione del tipo restituito. Dovrebbe essere usato solo
dove è richiesto il tipo restituito "OP *". La funzione non ritorna mai effettivamente.

OP * die(const char *pat, ...)

die_sv Si comporta come "croak_sv", ad eccezione del tipo restituito. Dovrebbe essere usato
solo dove è richiesto il tipo di ritorno "OP *". La funzione mai in realtà
ritorna.

OP * die_sv(SV *baseex)

vcroak Questa è un'interfaccia XS per la funzione "die" di Perl.

"pat" e "args" sono un modello di formato in stile sprintf e un argomento incapsulato
elenco. Questi vengono utilizzati per generare un messaggio di stringa. Se il messaggio non finisce
con una nuova riga, poi verrà estesa con qualche indicazione della corrente
posizione nel codice, come descritto per "mess_sv".

Il messaggio di errore verrà utilizzato come eccezione, restituendo il controllo a
il "eval" più vicino che lo racchiude, ma soggetto a modifica da parte di un $SIG{__DIE__}
gestore. In ogni caso la funzione "croak" non ritorna mai normalmente.

Per ragioni storiche, se "pat" è nullo, lo sarà anche il contenuto di "ERRSV" ($@).
utilizzato come messaggio di errore o oggetto invece di creare un messaggio di errore da
argomenti. Se vuoi lanciare un oggetto non stringa o creare un messaggio di errore in
un SV, è preferibile utilizzare la funzione "croak_sv", che non lo fa
implicano la distruzione di "ERRSV".

void vcroak(const char *pat, va_list *args)

vwarn Questa è un'interfaccia XS per la funzione "warn" di Perl.

"pat" e "args" sono un modello di formato in stile sprintf e un argomento incapsulato
elenco. Questi vengono utilizzati per generare un messaggio di stringa. Se il messaggio non finisce
con una nuova riga, poi verrà estesa con qualche indicazione della corrente
posizione nel codice, come descritto per "mess_sv".

Il messaggio di errore o l'oggetto verrà scritto per impostazione predefinita nell'errore standard, ma this
è soggetto a modifiche da parte di un gestore $SIG{__WARN__}.

A differenza di "vcroak", "pat" non può essere nullo.

void vwarn(const char *pat, va_list *args)

warn Questa è un'interfaccia XS per la funzione "warn" di Perl.

Prendi un modello di formato e un elenco di argomenti in stile sprintf. Questi sono usati per generare
un messaggio di stringa. Se il messaggio non termina con una nuova riga, lo sarà
esteso con qualche indicazione della posizione attuale nel codice, come descritto
per "mess_sv".

Il messaggio di errore o l'oggetto verrà scritto per impostazione predefinita nell'errore standard, ma this
è soggetto a modifiche da parte di un gestore $SIG{__WARN__}.

A differenza di "croak", "pat" non può essere nullo.

void warn(const char *pat, ...)

warn_sv Questa è un'interfaccia XS per la funzione "warn" di Perl.

"baseex" è il messaggio di errore o l'oggetto. Se è un riferimento, verrà utilizzato
come è. Altrimenti viene utilizzato come stringa e se non termina con un ritorno a capo
poi verrà esteso con qualche indicazione della posizione attuale nel codice,
come descritto per "mess_sv".

Il messaggio di errore o l'oggetto verrà scritto per impostazione predefinita nell'errore standard, ma this
è soggetto a modifiche da parte di un gestore $SIG{__WARN__}.

Per avvisare con un semplice messaggio di tipo stringa può essere più comoda la funzione “warn”.

void avvisa_sv(SV *baseex)

Non documentato funzioni

Le seguenti funzioni sono state contrassegnate come parte dell'API pubblica, ma lo sono attualmente
non documentato. Usali a tuo rischio e pericolo, poiché le interfacce sono soggette a modifiche.
Le funzioni che non sono elencate in questo documento non sono destinate all'uso pubblico, e dovrebbero
NON essere utilizzato in nessuna circostanza.

Se utilizzi una delle funzioni non documentate di seguito, potresti prendere in considerazione la creazione di e
presentando la relativa documentazione. Se la tua patch viene accettata, ciò indicherà che il file
l'interfaccia è stabile (a meno che non sia esplicitamente contrassegnato diversamente).

OttieniVars
Gv_AMupdate
PerlIO_clearerr
PerlIO_close
PerlIO_context_layers
PerlIO_eof
PerlIO_errore
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_non letto
PerlIO_write
amagic_call
amagic_deref_call
any_dup
atfork_lock
atfork_unlock
av_arylen_p
av_iter_p
blocca_dammi
call_atexit
lista_chiamate
calloc
cast_i32
cast_iv
cast_ulong
cast_uv
ck_warner
ck_warner_d
ckwarn
ckwarn_d
clone_params_del
clone_params_new
croak_memory_wrap
croak_nocontext
csighhandler
cx_dump
cx_dup
cxinc
debuttante
deb_nocontext
debop
debprofdump
debstack
debstackptrs
delimcpy
segnali_di_spedizione
die_nocontext
dirp_dup
do_aspawn
do_binmode
fare_chiudere
do_gv_dump
do_gvgv_dump
do_hv_dump
do_unisciti
do_magic_dump
do_op_dump
do_open
fare_apri9
do_openn
do_pmop_dump
do_spawn
do_spawn_nowait
do_sprintf
do_sv_dump
fare_contaminazione
doref
controvento
dowantarray
dump_eval
dump_form
dump_indent
dump_mstats
dump_sub
dump_vindent
filtro_aggiungi
filtro_del
filtro_leggi
foldEQ_latin1
form_nocontext
fp_dup
fprintf_nocontext
free_global_struct
free_tmps
ottieni_contesto
get_mstats
get_op_descs
get_op_names
get_ppadr
get_vtbl
gp_dup
gp_free
gp_rif
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
nome_gv_set
he_dup
hek_dup
hv_comune
hv_common_key_len
hv_delayfree_ent
hv_eiter_p
hv_eiter_set
hv_free_ent
hv_ksplit
hv_nome_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
istruire
is_lvalue_sub
lascia_ambito
load_module_nocontext
magic_dump
malloc
marktack_grow
mess_nocontext
mfree
mg_dup
mg_dimensione
mini_mktime
piùinterruttori
mro_get_from_name
mro_get_private_data
mro_set_mro
mro_set_private_data
mio_atof
mio_atof2
mia_bcopia
mio_bzero
mia_taglia
mio_cxt_index
mio_cxt_init
mio_dirfd
mia_uscita
mio_fallimento_uscita
my_fflush_all
la mia_forchetta
mio_lstat
my_memcmp
mio_memset
mio_pchiudi
mio_popen
mia_lista_popen
mio_setenv
my_socketpair
mia_stat
my_strftime
novitàANONATTRSUB
novitàANONHASH
nuovoANONLIST
nuovoANONSUB
nuovoATTRSUB
nuovoAVREF
nuovoCVREF
nuovoFORM
nuovoGVREF
nuovoGVgen
newGVgen_flags
nuovoHVREF
nuovoHVhv
nuovoIO
nuovoMYSUB
nuovoPROG
nuovoRV
nuovoSUB
nuovoSVREF
nuovoSVpvf_nocontext
new_stackinfo
ninstr
op_refcnt_lock
op_refcnt_unlock
parser_dup
perl_alloc_using
perl_clone_using
pmop_dump
pop_scope
pregcomp
pregexec
senza gravidanza
pregfree2
printf_nocontext
ptr_table_fetch
ptr_table_free
ptr_tabella_nuova
ptr_table_split
ptr_table_store
push_scope
ricompilare
re_dup_guts
re_intuit_start
re_intuit_string
rialloc
rientrante_libero
rientrante_init
rientrante_riprova
dimensione_rientrante
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
regdump
regdupe_internal
regexec_flags
regfree_internal
reginitcolors
regnex
ripeticpy
rninstr
segnale
rsignal_state
runops_debug
runops_standard
rvpv_dup
safesyscalloc
safesysfree
safesyssmalloc
safesysrealloc
salva_I16
salva_I32
salva_I8
save_adelete
save_aelem
save_aelem_flags
salva_alloc
salva_aptr
save_ary
save_bool
save_clearsv
salva_elimina
salva_distruttore
save_destructor_x
save_freeop
save_freepv
save_freesv
save_generic_pvref
save_generic_svref
salva_gp
salva_hash
save_hdelete
save_helem
save_helem_flags
save_hints
salva_hptr
salva_int
salva_oggetto
salva_iv
salva_lista
save_long
save_mortalizesv
save_nogv
salva_op
save_padsv_and_mortalize
save_pptr
save_pushi32ptr
save_pushptr
save_pushptrptr
salva_ri_contesto
save_scalar
save_set_svflags
save_shared_pvref
salva_sptr
salva_svref
salva_vptr
savestack_grow
savestack_grow_cnt
scan_num
scan_vstring
seme
set_contesto
set_numeric_local
set_radice_numerica
set_numeric_standard
condividi_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
sys_init
sys_init3
sys_intern_clear
sys_intern_dup
sys_intern_init
sys_term
taint_env
taint_proper
scollega
unsharepvn
utf16_to_utf8
utf16_to_utf8_reversed
uvuni_to_utf8
vdeb
vform
vload_modulo
vnewSVpvf
vwarner
warn_nocontext
ammonitore
warner_nocontext
qualesig
qualesig_pv
whatsig_pvn
whatsig_sv

AUTORI

Fino a maggio 1997, questo documento è stato mantenuto da Jeff Okamoto[email protected]>. è
ora mantenuto come parte del Perl stesso.

Con molto aiuto e suggerimenti da 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.

Elenco API originariamente di Dean Roehrich[email protected]>.

Aggiornato per essere generato automaticamente dai commenti nella fonte di Benjamin Stuhl.

Utilizza perlapi online utilizzando i servizi onworks.net