perlapi - En ligne dans le Cloud

PROGRAMME:

Nom

perlapi - documentation générée automatiquement pour l'API publique perl

DESCRIPTION

Ce fichier contient la documentation de l'API publique perl générée par intégrer.pl,
spécifiquement une liste de fonctions, macros, indicateurs et variables qui peuvent être utilisés par
rédacteurs de vulgarisation. A la fin se trouve une liste de fonctions qui n'ont pas encore été documentées.
Les interfaces de ceux-ci sont susceptibles d'être modifiées sans préavis. Tout ce qui n'est pas répertorié ici est
ne fait pas partie de l'API publique et ne doit pas du tout être utilisé par les auteurs d'extensions. Pour ces
raisons, l'utilisation aveugle des fonctions répertoriées dans proto.h est à éviter lors de l'écriture
Extensions.

Notez que toutes les variables globales de l'API Perl doivent être référencées avec le préfixe "PL_". Encore,
ceux qui ne sont pas répertoriés ici ne doivent pas être utilisés par les auteurs d'extensions et peuvent être modifiés ou
supprimé sans préavis ; idem avec les macros. Certaines macros sont fournies pour la compatibilité avec
les noms plus anciens et sans fioritures, mais cette prise en charge peut être désactivée dans une version future.

Perl a été écrit à l'origine pour gérer uniquement l'US-ASCII (c'est-à-dire les caractères dont l'ordinal
les nombres sont compris entre 0 et 127). Et la documentation et les commentaires peuvent toujours utiliser le terme
ASCII, alors que parfois en fait toute la plage de 0 à 255 est signifiée.

Notez que Perl peut être compilé et exécuté sous ASCII ou EBCDIC (voir perlebcdic).
La plupart de la documentation (et même les commentaires dans le code) ignorent la possibilité EBCDIC.
Dans presque tous les cas, les différences sont transparentes. À titre d'exemple, sous EBCDIC,
au lieu d'UTF-8, UTF-EBCDIC est utilisé pour coder des chaînes Unicode, et donc chaque fois que cela
la documentation fait référence à "utf8" (et aux variantes de ce nom, y compris dans les noms de fonction),
il signifie également (essentiellement de manière transparente) "UTF-EBCDIC". Mais les ordinaux des personnages
diffèrent entre les codages ASCII, EBCDIC et UTF, et une chaîne codée en UTF-EBCDIC
peut occuper plus d'octets qu'en UTF-8.

La liste ci-dessous est alphabétique, insensible à la casse.

"Donne-moi" Nos valeurs

GIMME Une version rétrocompatible de "GIMME_V" qui ne peut renvoyer que "G_SCALAR" ou
"G_ARRAY" ; dans un contexte vide, il renvoie "G_SCALAIRE". Obsolète. Utilisez "GIMME_V"
à la place.

U32 GOMME

GIMME_V L'équivalent du XSUB-writer du "wantarray" de Perl. Renvoie "G_VOID", "G_SCALAR"
ou "G_ARRAY" pour le contexte vide, scalaire ou de liste, respectivement. Voir perlcall pour un
exemple d'utilisation.

U32 GIMME_V

G_ARRAY Utilisé pour indiquer le contexte de la liste. Voir "GIMME_V", "GIMME" et perlcall.

G_DISCARD
Indique que les arguments renvoyés par un rappel doivent être ignorés. Voir
appel perl.

G_EVAL Utilisé pour forcer un wrapper "eval" Perl autour d'un rappel. Voir perlcall.

G_NOARGS
Indique qu'aucun argument n'est envoyé à un rappel. Voir perlcall.

G_SCALAIRE
Utilisé pour indiquer le contexte scalaire. Voir "GIMME_V", "GIMME" et perlcall.

G_VOID Utilisé pour indiquer le contexte vide. Voir "GIMME_V" et perlcall.

tableau Manipulation Les fonctions

AvFILL Identique à "av_top_index()". Obsolète, utilisez plutôt "av_top_index()".

int REMPLISSAGE(AV* moy)

av_clear
Libère tous les éléments d'un tableau, le laissant vide. L'équivalent XS de
"@tableau = ()". Voir aussi "av_undef".

Notez qu'il est possible que les actions d'un destructeur appelé directement ou
indirectement en libérant un élément du tableau pourrait provoquer le décompte de références de
le tableau lui-même à réduire (par exemple en supprimant une entrée dans la table des symboles). Alors
il est possible que l'AV ait pu être libéré (ou même réaffecté) sur
revenir de l'appel à moins que vous ne déteniez une référence à celui-ci.

annuler av_clear(AV *av)

av_create_and_push
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Poussez un SV à l'extrémité du tableau, créant le tableau si nécessaire. Un petit
fonction d'assistance interne pour supprimer un idiome couramment dupliqué.

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

av_create_and_unshift_one
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Déplace un SV au début du tableau, créant le tableau si nécessaire.
Une petite fonction d'aide interne pour supprimer un idiome couramment dupliqué.

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

av_delete
Supprime l'élément indexé par "key" du tableau, rend l'élément mortel et
le renvoie. Si "flags" est égal à "G_DISCARD", l'élément est libéré et null est
revenu. Équivalent Perl : "mon $elem = delete($myarray[$idx]);" pour le
version non "G_DISCARD" et un contexte vide "delete($myarray[$idx]);" pour le
Version "G_DISCARD".

SV* av_delete(AV *av, clé SSize_t, drapeaux I32)

av_existe
Renvoie true si l'élément indexé par "key" a été initialisé.

Cela repose sur le fait que les éléments de tableau non initialisés sont définis sur NULL.

Équivalent Perl : "existe($myarray[$key])".

bool av_exists (AV * av, clé SSize_t)

av_extend
Pré-étendre un tableau. La "clé" est l'index auquel le tableau doit être
élargi.

void av_extend (AV * av, clé SSize_t)

av_fetch
Renvoie le SV à l'index spécifié dans le tableau. La "clé" est l'index. Si
lval est vrai, vous êtes assuré de récupérer un vrai SV (au cas où ce n'était pas réel
avant), que vous pouvez ensuite modifier. Vérifiez que la valeur de retour est non nulle
avant de le déréférencer à un "SV*".

Voir "Comprendre la magie des hachages et des tableaux liés" dans perlguts pour en savoir plus
informations sur la façon d'utiliser cette fonction sur des tableaux liés.

L'équivalent approximatif de Perl est $myarray[$idx].

SV** av_fetch (AV * av, clé SSize_t, I32 lval)

av_fill Définit l'index le plus élevé du tableau au nombre donné, équivalent à celui de Perl
"$#array = $fill;".

Le nombre d'éléments dans le tableau sera "remplir + 1" après av_fill() résultats.
Si le tableau était auparavant plus court, les éléments supplémentaires ajoutés sont définis
à NULL. Si le tableau était plus long, les éléments en excès sont libérés.
"av_fill(av, -1)" est identique à "av_clear(av)".

void av_fill(AV *av, SSize_t remplir)

av_len Identique à "av_top_index". Notez que, contrairement à ce que son nom implique, il renvoie le
indice le plus élevé du tableau, donc pour obtenir la taille du tableau que vous devez utiliser
"av_len(av) + 1". Ceci est différent de "sv_len", qui renvoie ce que vous attendez.

SSize_t av_len(AV * av)

av_make Crée un nouveau AV et le remplit avec une liste de SV. Les SV sont copiés dans le
array, de sorte qu'ils peuvent être libérés après l'appel à av_make. Le nouveau AV aura un
nombre de références de 1.

Équivalent Perl : "mon @new_array = ($scalar1, $scalar2, $scalar3...);"

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

av_pop Supprime un SV de la fin du tableau, réduisant sa taille d'un et retournant
le SV (transfert du contrôle d'un compteur de références) à l'appelant. Retour
&PL_sv_undef si le tableau est vide.

Équivalent Perl : "pop(@myarray);"

SV* av_pop(AV *av)

av_push Pousse un SV à la fin du tableau. Le tableau s'étendra automatiquement jusqu'à
accueillir l'addition. Cela prend possession d'un nombre de références.

Équivalent Perl : "push @myarray, $elem;".

void av_push(AV *av, SV *val)

av_shift
Supprime un SV du début du tableau, réduisant sa taille d'un et retournant
le SV (transfert du contrôle d'un compteur de références) à l'appelant. Retour
&PL_sv_undef si le tableau est vide.

Équivalent Perl : "shift(@myarray);"

SV* moy_shift(AV * moy)

av_store
Stocke un SV dans un tableau. L'index du tableau est spécifié comme "clé". Le retour
valeur sera NULL si l'opération a échoué ou si la valeur n'avait pas besoin d'être
réellement stockées dans le tableau (comme dans le cas des tableaux liés). Sinon, il
peut être déréférencé pour récupérer le "SV*" qui y était stocké (= "val")).

Notez que l'appelant est responsable de l'incrémentation appropriée du nombre de références
de "val" avant l'appel, et en le décrémentant si la fonction a renvoyé NULL.

Équivalent Perl approximatif : "$myarray[$key] = $val;".

Voir "Comprendre la magie des hachages et des tableaux liés" dans perlguts pour en savoir plus
informations sur la façon d'utiliser cette fonction sur des tableaux liés.

SV** av_store(AV *av, clé SSize_t, SV *val)

av_tindex
Identique à "av_top_index()".

int av_tindex(AV* av)

av_top_index
Renvoie l'indice le plus élevé du tableau. Le nombre d'éléments dans le tableau est
"av_top_index(av) + 1". Renvoie -1 si le tableau est vide.

L'équivalent Perl pour cela est $#myarray.

(Une forme légèrement plus courte est "av_tindex".)

SSize_t av_top_index(AV * av)

av_undef
Dédéfinit le tableau. L'équivalent XS de "undef(@array)".

En plus de libérer tous les éléments du tableau (comme "av_clear()"), cela
libère la mémoire utilisée par l'av pour stocker sa liste de scalaires.

Voir "av_clear" pour une note sur le tableau pouvant être invalide au retour.

annuler av_undef(AV *av)

av_unshift
Décalez le nombre donné de valeurs "undef" au début du tableau. le
le tableau grandira automatiquement pour s'adapter à l'ajout. Vous devez alors utiliser
"av_store" pour attribuer des valeurs à ces nouveaux éléments.

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

void av_unshift(AV *av, SSize_t num)

get_av Renvoie l'AV du tableau global ou package Perl spécifié avec le nom donné
(donc cela ne fonctionnera pas sur les variables lexicales). Les "drapeaux" sont passés à "gv_fetchpv". Si
"GV_ADD" est défini et la variable Perl n'existe pas alors elle sera créée. Si
"flags" vaut zéro et la variable n'existe pas, alors NULL est renvoyé.

Équivalent Perl : "@{"$nom"}".

REMARQUE : la forme perl_ de cette fonction est dépréciée.

AV* get_av(const char *nom, indicateurs I32)

newAV Crée un nouveau AV. Le compteur de référence est défini sur 1.

Équivalent Perl : "mon @array;".

AV* nouveauAV()

sortsv Trie un tableau. Voici un exemple:

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

Actuellement, cela utilise toujours mergesort. Voir sortsv_flags pour plus de flexibilité
routine.

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

sortesv_flags
Trier un tableau, avec diverses options.

void sortsv_flags (tableau SV**, size_t num_elts,
SVCOMPARE_t cmp, drapeaux U32)

"xsubpp" les variables et interne fonctions

ax Variable qui est configurée par "xsubpp" pour indiquer le décalage de base de la pile, utilisé par le
Macros "ST", "XSprePUSH" et "XSRETURN". La macro "dMARK" doit être appelée avant
pour configurer la variable "MARK".

hache I32

CLASS Variable qui est configurée par "xsubpp" pour indiquer le nom de classe pour un C++ XS
constructeur. C'est toujours un "car*". Regarde ça".

caractère* CLASSE

dAX Configure la variable "ax". Ceci est généralement géré automatiquement par "xsubpp" par
en appelant "dXSARGS".

dAX ;

dAXMARK Définit la variable "ax" et la variable de marqueur de pile "mark". C'est généralement
géré automatiquement par "xsubpp" en appelant "dXSARGS".

dAXMARK ;

dITEMS Configure la variable "items". Ceci est généralement géré automatiquement par "xsubpp"
en appelant "dXSARGS".

dÉLÉMENTS ;

BARRE D'APPUI
Configure toute variable requise par la macro "UNDERBAR". Il définissait
"padoff_du", mais c'est actuellement un noop. Cependant, il est fortement conseillé de toujours
l'utiliser pour assurer la compatibilité passée et future.

BARRE D'APPUI ;

dXSARGS Configure des pointeurs de pile et de marque pour une XSUB, en appelant dSP et dMARK. Met en place le
variables "ax" et "items" en appelant "dAX" et "dITEMS". Ceci est généralement géré
automatiquement par "xsubpp".

dXSARGS ;

dXSI32 Configure la variable "ix" pour une XSUB qui a des alias. Ceci est généralement géré
automatiquement par "xsubpp".

dXSI32 ;

items Variable qui est configurée par "xsubpp" pour indiquer le nombre d'éléments sur la pile.
Voir "Listes de paramètres de longueur variable" dans perlxs.

I32 articles

ix Variable qui est configurée par "xsubpp" pour indiquer lequel des alias d'une XSUB était
utilisé pour l'invoquer. Voir "L'ALIAS : Mot-clé" dans perlxs.

I32ix

RETVAL Variable qui est configurée par "xsubpp" pour contenir la valeur de retour d'un XSUB. C'est
toujours le type approprié pour la XSUB. Voir "La variable RETVAL" dans perlxs.

(peu importe) RETVAL

ST Utilisé pour accéder aux éléments de la pile de la XSUB.

SV* ST(intix)

CETTE variable qui est configurée par "xsubpp" pour désigner l'objet dans une XSUB C++. Cette
est toujours le type approprié pour l'objet C++. Voir "CLASS" et "Utiliser XS avec C++"
en perlxs.

(peu importe) CECI

SOUS BARRE
Le SV* correspondant à la variable $_. Fonctionne même s'il y a un lexical $_ dans
portée.

Macro XS pour déclarer une XSUB et sa liste de paramètres C. Ceci est géré par "xsubpp".
C'est la même chose que d'utiliser la macro XS_EXTERNAL plus explicite.

XS_EXTERNE
Macro pour déclarer une XSUB et sa liste de paramètres C exportant explicitement le
symboles

XS_INTERNE
Macro pour déclarer une XSUB et sa liste de paramètres C sans exporter les symboles.
Ceci est géré par "xsubpp" et généralement préférable à l'exportation de la XSUB
symboles inutilement.

Rappel Les fonctions

appel_argv
Exécute un rappel vers le sous-programme Perl nommé et d'étendue de package spécifié avec
"argv" (un tableau de chaînes terminé par NULL) comme arguments. Voir perlcall.

Équivalent Perl approximatif : "&{"$sub_name"}(@$argv)".

REMARQUE : la forme perl_ de cette fonction est dépréciée.

I32 call_argv(const char* sub_name, indicateurs I32,
car** argv)

méthode_appel
Exécute un rappel à la méthode Perl spécifiée. L'objet béni doit être sur
la pile. Voir perlcall.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

I32 call_method (const char * methname, indicateurs I32)

call_pv Exécute un rappel vers le sous-marin Perl spécifié. Voir perlcall.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

I32 call_pv(const char* sub_name, indicateurs I32)

call_sv Exécute un rappel vers le sous-système Perl spécifié par le SV.

Si ni le drapeau "G_METHOD" ni "G_METHOD_NAMED" n'est fourni, le SV peut être n'importe quel
d'un CV, un GV, une référence à un CV, une référence à un GV ou "SvPV(sv)" sera utilisé
comme nom du sous-marin à appeler.

Si le drapeau "G_METHOD" est fourni, le SV peut être une référence à un CV ou
"SvPV(sv)" sera utilisé comme nom de la méthode à appeler.

Si le drapeau "G_METHOD_NAMED" est fourni, "SvPV(sv)" sera utilisé comme nom de
la méthode à appeler.

Certaines autres valeurs sont traitées spécialement pour un usage interne et ne doivent pas être
dépendait de.

Voir perlcall.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

I32 call_sv(SV* sv, indicateurs VOL I32)

ENTER Parenthèse ouvrante sur un rappel. Voir "QUITTER" et perlcall.

ENTRER;

eval_pv Indique à Perl d'"évaluer" la chaîne donnée dans un contexte scalaire et de renvoyer un résultat SV*.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

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

eval_sv Indique à Perl d'"évaluer" la chaîne dans le SV. Il prend en charge les mêmes drapeaux que
"call_sv", à l'exception évidente de G_EVAL. Voir perlcall.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

I32 eval_sv (SV* sv, indicateurs I32)

GRATUITTMPS
Parenthèse de fermeture pour les temporaires sur un rappel. Voir "SAVETMPS" et perlcall.

FREETMPS ;

LEAVE Parenthèse fermante sur un rappel. Voir "ENTRER" et perlcall.

LAISSER;

SAUVEGARDERTMPS
Parenthèse ouvrante pour les temporaires sur un rappel. Voir "FREETMPS" et perlcall.

SAVETMPS ;

Personnage maisons en changeant

toFOLD Convertit le caractère spécifié en foldcase. Si l'entrée est autre chose qu'un
Caractère majuscule ASCII, ce caractère d'entrée lui-même est renvoyé. Une variante
"toFOLD_A" est équivalent. (Il n'y a pas d'équivalent "to_FOLD_L1" pour le plein
Plage Latin1, car la généralité complète de "toFOLD_uni" y est nécessaire.)

U8 àPLIER (U8 canaux)

àFOLD_uni
Convertit le point de code Unicode "cp" en sa version foldcase et le stocke dans
UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon pointait vers
par "s" doit être d'au moins "UTF8_MAXBYTES_CASE+1" octets depuis le foldcase
version peut être plus longue que le caractère original.

Le premier point de code de la version foldcase est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

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

àFOLD_utf8
Convertit le caractère encodé UTF-8 à "p" en sa version foldcase et stocke
celle en UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon
pointé par "s" doit être au moins "UTF8_MAXBYTES_CASE+1" octets puisque le
La version foldcase peut être plus longue que le caractère original.

Le premier point de code de la version foldcase est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

Le caractère d'entrée à "p" est supposé être bien formé.

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

toLOWER Convertit le caractère spécifié en minuscule. Si l'entrée est autre chose qu'un
Caractère majuscule ASCII, ce caractère d'entrée lui-même est renvoyé. Une variante
"toLOWER_A" est équivalent.

U8 à INFÉRIEUR(U8 ch)

àLOWER_L1
Convertit le caractère Latin1 spécifié en minuscule. Les résultats ne sont pas définis
si l'entrée ne tient pas dans un octet.

U8 àLOWER_L1(U8 canal)

àLOWER_LC
Convertit le caractère spécifié en minuscule en utilisant les règles de la locale actuelle, si
possible; sinon renvoie le caractère d'entrée lui-même.

U8 àLOWER_LC(U8 canaux)

àLOWER_uni
Convertit le point de code Unicode "cp" en sa version minuscule et le stocke dans
UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon pointait vers
par "s" doit être au moins "UTF8_MAXBYTES_CASE+1" octets depuis la minuscule
version peut être plus longue que le caractère original.

Le premier point de code de la version en minuscules est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

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

àLOWER_utf8
Convertit le caractère encodé UTF-8 à "p" en sa version minuscule et stocke
celle en UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon
pointé par "s" doit être au moins "UTF8_MAXBYTES_CASE+1" octets puisque le
la version minuscule peut être plus longue que le caractère original.

Le premier point de code de la version en minuscules est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

Le caractère d'entrée à "p" est supposé être bien formé.

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

toTITLE Convertit le caractère spécifié en casse de titre. Si l'entrée est autre chose qu'un
Caractère minuscule ASCII, ce caractère d'entrée lui-même est renvoyé. Une variante
"toTITLE_A" est équivalent. (Il n'y a pas de "toTITLE_L1" pour toute la gamme Latin1,
car la généralité complète de "toTITLE_uni" y est nécessaire. La casse n'est pas un
concept utilisé dans la gestion des paramètres régionaux, il n'y a donc aucune fonctionnalité pour cela.)

U8 à TITRE(U8 ch)

à TITLE_uni
Convertit le point de code Unicode « cp » en sa version de casse de titre et le stocke dans
UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon pointait vers
par "s" doit être d'au moins "UTF8_MAXBYTES_CASE+1" octets depuis la casse du titre
version peut être plus longue que le caractère original.

Le premier point de code de la version titlecase est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

UV àTITLE_uni(UV cp, U8* s, STRLEN* lenp)

àTITLE_utf8
Convertit le caractère encodé UTF-8 à "p" en sa version de casse de titre et stocke
celle en UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon
pointé par "s" doit être au moins "UTF8_MAXBYTES_CASE+1" octets puisque le
la version de la casse peut être plus longue que le caractère original.

Le premier point de code de la version titlecase est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

Le caractère d'entrée à "p" est supposé être bien formé.

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

toUPPER Convertit le caractère spécifié en majuscule. Si l'entrée est autre chose qu'un
Caractère minuscule ASCII, ce caractère d'entrée lui-même est renvoyé. Une variante
"toUPPER_A" est équivalent.

U8 àUPPER(U8 ch)

àUPPER_uni
Convertit le point de code Unicode "cp" en sa version majuscule et le stocke dans
UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon pointait vers
par "s" doit être d'au moins "UTF8_MAXBYTES_CASE+1" octets depuis la majuscule
version peut être plus longue que le caractère original.

Le premier point de code de la version en majuscule est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

UV àUPPER_uni(UV cp, U8* s, STRLEN* lenp)

àUPPER_utf8
Convertit le caractère encodé UTF-8 à "p" en sa version majuscule et stocke
celle en UTF-8 en "s", et sa longueur en octets en "lenp". Notez que le tampon
pointé par "s" doit être au moins "UTF8_MAXBYTES_CASE+1" octets puisque le
la version majuscule peut être plus longue que le caractère original.

Le premier point de code de la version en majuscule est renvoyé (mais notez, comme expliqué
juste au-dessus, qu'il peut y avoir plus.)

Le caractère d'entrée à "p" est supposé être bien formé.

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

Personnage classification

Cette section concerne les fonctions (en réalité les macros) qui classent les caractères en types, tels que
comme la ponctuation par rapport à l'alphabétique, etc. La plupart d'entre eux sont analogues à l'expression régulière
classes de personnages. (Voir "Classes de caractères POSIX" dans perlrecharclass.) Il existe plusieurs
variantes pour chaque classe. (Toutes les macros n'ont pas toutes les variantes ; chaque élément ci-dessous répertorie les
valides pour cela.) Aucun n'est affecté par "use bytes", et seuls ceux avec "LC" dans le
nom sont affectés par les paramètres régionaux actuels.

La fonction de base, par exemple, "isALPHA()", prend un octet (soit un "char" soit un "U8") en entrée
et renvoie un booléen pour savoir si le caractère représenté par cet octet est (ou
sur les plates-formes non ASCII, correspond à) un caractère ASCII dans la classe nommée basée sur
les règles de plate-forme, Unicode et Perl. Si l'entrée est un nombre qui ne tient pas dans un octet,
FALSE est renvoyé.

La variante "isFOO_A" (par exemple, "isALPHA_A()") est identique à la fonction de base sans suffixe
"_UNE".

La variante "isFOO_L1" impose le jeu de caractères Latin-1 (ou l'équivalent EBCDIC) sur le
Plate-forme. C'est-à-dire que les points de code qui sont ASCII ne sont pas affectés, puisque ASCII est un sous-ensemble
de Latin-1. Mais les points de code non ASCII sont traités comme s'il s'agissait de caractères Latin-1.
Par exemple, "isWORDCHAR_L1()" retournera vrai lorsqu'il est appelé avec le point de code 0xDF,
qui est un caractère de mot à la fois en ASCII et en EBCDIC (bien qu'il représente différents
caractères dans chacun).

La variante "isFOO_uni" est comme la variante "isFOO_L1", mais accepte n'importe quel point de code UV comme
saisir. Si le point de code est supérieur à 255, les règles Unicode sont utilisées pour déterminer s'il est
dans la classe des personnages. Par example, "estWORDCHAR_uni(0x100)" renvoie VRAI, puisque 0x100 est
LETTRE MAJUSCULE LATINE A AVEC MACRON en Unicode, et est un caractère de mot.

La variante "isFOO_utf8" est comme "isFOO_uni", mais l'entrée est un pointeur vers un (connu pour être
chaîne encodée UTF-8 ("U8*" ou "char*"). Le classement des seuls
le premier caractère (éventuellement multi-octets) de la chaîne est testé.

La variante "isFOO_LC" est comme les variantes "isFOO_A" et "isFOO_L1", mais le résultat est basé
sur les paramètres régionaux actuels, ce que signifie "LC" dans le nom. Si Perl peut déterminer
que la locale actuelle est une locale UTF-8, elle utilise les règles Unicode publiées ; autrement,
il utilise la fonction de bibliothèque C qui donne la classification nommée. Par example,
"isDIGIT_LC()" lorsqu'il n'est pas dans une locale UTF-8 renvoie le résultat de l'appel de "isdigit()".
FALSE est toujours renvoyé si l'entrée ne rentre pas dans un octet. Sur certaines plateformes où
la fonction de bibliothèque C est connue pour être défectueuse, Perl modifie son résultat pour suivre le
Règles de la norme POSIX.

La variante "isFOO_LC_uvchr" est comme "isFOO_LC", mais est définie sur n'importe quel UV. Il renvoie le
identique à "isFOO_LC" pour les points de code d'entrée inférieurs à 256, et renvoie le code codé en dur, non-
affecté-par-locale, les résultats Unicode pour les plus grands.

La variante "isFOO_LC_utf8" est comme "isFOO_LC_uvchr", mais l'entrée est un pointeur vers un (connu
être bien formé) chaîne encodée UTF-8 ("U8*" ou "char*"). La classification de juste
le premier caractère (éventuellement multi-octets) de la chaîne est testé.

isALPHA Renvoie un booléen indiquant si le caractère spécifié est un caractère alphabétique
caractère, analogue à "m/[[:alpha:]]/". Voir le haut de cette section pour un
explication des variantes "isALPHA_A", "isALPHA_L1", "isALPHA_uni", "isALPHA_utf8",
"isALPHA_LC", "isALPHA_LC_uvchr" et "isALPHA_LC_utf8".

booléen estALPHA(char ch)

estALPHANUMÉRIQUE
Renvoie un booléen indiquant si le caractère spécifié est soit un
caractère alphabétique ou chiffre décimal, analogue à "m/[[:alnum:]]/". Voir le haut
de cette section pour une explication des variantes "isALPHANUMERIC_A",
"isALPHANUMERIC_L1", "isALPHANUMERIC_uni", "isALPHANUMERIC_utf8",
"isALPHANUMERIC_LC", "isALPHANUMERIC_LC_uvchr" et "isALPHANUMERIC_LC_utf8".

bool estALPHANUMERIQUE(char ch)

isASCII Renvoie un booléen indiquant si le caractère spécifié fait partie des 128
caractères dans le jeu de caractères ASCII, analogue à "m/[[:ascii:]]/". Sur non-
plates-formes ASCII, il renvoie TRUE si ce caractère correspond à un ASCII
personnage. Les variantes "isASCII_A()" et "isASCII_L1()" sont identiques à
"estASCII()". Voir le haut de cette section pour une explication des variantes
"isASCII_uni", "isASCII_utf8", "isASCII_LC", "isASCII_LC_uvchr", et
"isASCII_LC_utf8". Notez cependant que certaines plateformes n'ont pas la bibliothèque C
routine "isascii()". Dans ces cas, les variantes dont les noms contiennent « LC » sont
les mêmes que les correspondants sans.

Notez également que parce que tous les caractères ASCII sont invariants UTF-8 (ce qui signifie qu'ils
ont exactement la même représentation (toujours un seul octet) qu'elles soient codées en UTF-8
ou non), "isASCII" donnera les résultats corrects lorsqu'il est appelé avec n'importe quel octet dans n'importe quel
chaîne encodée ou non en UTF-8. Et de même "isASCII_utf8" fonctionnera correctement
sur n'importe quelle chaîne encodée ou non en UTF-8.

booléen isASCII(char ch)

isBLANK Renvoie un booléen indiquant si le caractère spécifié est un caractère
considéré comme un blanc, analogue à "m/[[:blank:]]/". Voir en haut de ceci
section pour une explication des variantes "isBLANK_A", "isBLANK_L1", "isBLANK_uni",
"isBLANK_utf8", "isBLANK_LC", "isBLANK_LC_uvchr" et "isBLANK_LC_utf8". Noter,
cependant, que certaines plates-formes n'ont pas la routine de bibliothèque C "isblank()". Dans
ces cas, les variantes dont les noms contiennent « LC » sont les mêmes que les
correspondants sans.

booléen estVIDE(char ch)

isCNTRL Renvoie un booléen indiquant si le caractère spécifié est un contrôle
caractère, analogue à "m/[[:cntrl:]]/". Voir le haut de cette section pour un
explication des variantes "isCNTRL_A", "isCNTRL_L1", "isCNTRL_uni", "isCNTRL_utf8",
"isCNTRL_LC", "isCNTRL_LC_uvchr" et "isCNTRL_LC_utf8" Sur les plateformes EBCDIC, vous
veulent presque toujours utiliser la variante "isCNTRL_L1".

booléen isCNTRL(char ch)

isDIGIT Renvoie un booléen indiquant si le caractère spécifié est un chiffre, analogue
à "m/[[:chiffre:]]/". Les variantes "isDIGIT_A" et "isDIGIT_L1" sont identiques à
"isDIGIT". Voir le haut de cette section pour une explication des variantes
"isDIGIT_uni", "isDIGIT_utf8", "isDIGIT_LC", "isDIGIT_LC_uvchr", et
"isDIGIT_LC_utf8".

bool isDIGIT(car ch)

isGRAPH Renvoie un booléen indiquant si le caractère spécifié est un graphique
caractère, analogue à "m/[[:graph:]]/". Voir le haut de cette section pour un
explication des variantes "isGRAPH_A", "isGRAPH_L1", "isGRAPH_uni", "isGRAPH_utf8",
"isGRAPH_LC", "isGRAPH_LC_uvchr" et "isGRAPH_LC_utf8".

booléen isGRAPH(char ch)

estIDCONT
Renvoie un booléen indiquant si le caractère spécifié peut être le deuxième ou
caractère suivant d'un identifiant. C'est très proche, mais pas tout à fait le
identique à la propriété officielle Unicode "XID_Continue". La différence est que ce
renvoie vrai uniquement si le caractère d'entrée correspond également à "isWORDCHAR". Voir le haut
de cette section pour une explication des variantes "isIDCONT_A", "isIDCONT_L1",
"isIDCONT_uni", "isIDCONT_utf8", "isIDCONT_LC", "isIDCONT_LC_uvchr", et
"isIDCONT_LC_utf8".

booléen isIDCONT(char ch)

estIDFIRST
Renvoie un booléen indiquant si le caractère spécifié peut être le premier
caractère d'un identifiant. C'est très proche, mais pas tout à fait le même que le
propriété Unicode officielle "XID_Start". La différence est que cela renvoie vrai
uniquement si le caractère saisi correspond également à "isWORDCHAR". Voir en haut de ceci
section pour une explication des variantes "isIDFIRST_A", "isIDFIRST_L1",
"isIDFIRST_uni", "isIDFIRST_utf8", "isIDFIRST_LC", "isIDFIRST_LC_uvchr", et
"isIDFIRST_LC_utf8".

bool estIDFIRST(char ch)

isLOWER Renvoie un booléen indiquant si le caractère spécifié est une minuscule
caractère, analogue à "m/[[:lower:]]/". Voir le haut de cette section pour un
explication des variantes "isLOWER_A", "isLOWER_L1", "isLOWER_uni", "isLOWER_utf8",
"isLOWER_LC", "isLOWER_LC_uvchr" et "isLOWER_LC_utf8".

booléen est INFÉRIEUR(char ch)

isOCTAL Renvoie un booléen indiquant si le caractère spécifié est un chiffre octal,
[0-7]. Les deux seules variantes sont "isOCTAL_A" et "isOCTAL_L1" ; chacun est identique
à "isOCTAL".

booléen isOCTAL(char ch)

isPRINT Renvoie un booléen indiquant si le caractère spécifié est imprimable
caractère, analogue à "m/[[:print:]]/". Voir le haut de cette section pour un
explication des variantes "isPRINT_A", "isPRINT_L1", "isPRINT_uni", "isPRINT_utf8",
"isPRINT_LC", "isPRINT_LC_uvchr" et "isPRINT_LC_utf8".

bool estPRINT(char ch)

estPSXSPC
(abréviation de Posix Space) À partir de 5.18, c'est identique sous toutes ses formes à
les macros "isSPACE()" correspondantes. Les formes locales de cette macro sont
identiques à leurs formulaires "isSPACE()" correspondants dans toutes les versions de Perl. Dans
versions antérieures à 5.18, les formes non locales diffèrent de leurs formes "isSPACE()"
seulement en ce que les formulaires "isSPACE()" ne correspondent pas à un onglet vertical, et le
Les formulaires "isPSXSPC()" le font. Sinon ils sont identiques. Cette macro est donc
analogue à ce que "m/[[:space:]]/" correspond dans une expression régulière. Voir le haut
de cette section pour une explication des variantes "isPSXSPC_A", "isPSXSPC_L1",
"isPSXSPC_uni", "isPSXSPC_utf8", "isPSXSPC_LC", "isPSXSPC_LC_uvchr", et
"isPSXSPC_LC_utf8".

booléen isPSXSPC(char ch)

isPUNCT Renvoie un booléen indiquant si le caractère spécifié est une ponctuation
caractère, analogue à "m/[[:punct:]]/". Notez que la définition de ce qui est
la ponctuation n'est pas aussi simple qu'on pourrait le souhaiter. Voir "Caractère POSIX
Classes" dans perlrecharclass pour plus de détails. Voir le haut de cette section pour un
explication des variantes "isPUNCT_A", "isPUNCT_L1", "isPUNCT_uni", "isPUNCT_utf8",
"isPUNCT_LC", "isPUNCT_LC_uvchr" et "isPUNCT_LC_utf8".

bool estPUNCT(char ch)

isSPACE Renvoie un booléen indiquant si le caractère spécifié est un espace
personnage. Ceci est analogue à ce que "m/\s/" correspond dans une expression régulière.
À partir de Perl 5.18, cela correspond également à ce que fait "m/[[:space:]]/". Antérieur à
5.18, uniquement les formes locales de cette macro (celles avec "LC" dans leurs noms)
correspond exactement à ce que fait "m/[[:space:]]/". Dans ces versions, le seul
différence, dans les variantes non locales, était que "isSPACE()" ne correspondait pas à un
onglet vertical. (Voir "isPSXSPC" pour une macro qui correspond à un onglet vertical dans tous les
versions.) Voir le haut de cette section pour une explication des variantes
"isSPACE_A", "isSPACE_L1", "isSPACE_uni", "isSPACE_utf8", "isSPACE_LC",
"isSPACE_LC_uvchr" et "isSPACE_LC_utf8".

booléen est ESPACE(char ch)

isUPPER Renvoie un booléen indiquant si le caractère spécifié est une majuscule
caractère, analogue à "m/[[:upper:]]/". Voir le haut de cette section pour un
explication des variantes "isUPPER_A", "isUPPER_L1", "isUPPER_uni", "isUPPER_utf8",
"isUPPER_LC", "isUPPER_LC_uvchr" et "isUPPER_LC_utf8".

bool estUPPER(char ch)

estWORDCHAR
Renvoie un booléen indiquant si le caractère spécifié est un caractère qui
est un caractère de mot, analogue à ce que "m/\w/" et "m/[[:word:]]/" correspondent dans un
expression régulière. Un caractère de mot est un caractère alphabétique, un chiffre décimal,
un caractère de ponctuation de connexion (comme un trait de soulignement) ou un caractère « marque »
qui s'attache à l'un d'entre eux (comme une sorte d'accent). "isALNUM()" est un
synonyme fourni pour la compatibilité descendante, même si un caractère de mot comprend
plus que la signification alphanumérique standard du langage C. Voir en haut de ceci
section pour une explication des variantes "isWORDCHAR_A", "isWORDCHAR_L1",
"isWORDCHAR_uni" et "isWORDCHAR_utf8". "isWORDCHAR_LC", "isWORDCHAR_LC_uvchr",
et "isWORDCHAR_LC_utf8" sont également tels que décrits ici, mais incluent en plus le
le trait de soulignement natif de la plate-forme.

booléen estWORDCHAR(char ch)

estXDIGIT
Renvoie un booléen indiquant si le caractère spécifié est un hexadécimal
chiffre. Dans la plage ASCII, il s'agit de "[0-9A-Fa-f]". Variantes "isXDIGIT_A()" et
"isXDIGIT_L1()" sont identiques à "isXDIGIT()". Voir le haut de cette section pour un
explication des variantes "isXDIGIT_uni", "isXDIGIT_utf8", "isXDIGIT_LC",
"isXDIGIT_LC_uvchr" et "isXDIGIT_LC_utf8".

bool estXDIGIT(car ch)

Clonage an interprète

perl_clone
Créez et renvoyez un nouvel interpréteur en clonant l'actuel.

perl_clone prend ces drapeaux comme paramètres :

CLONEf_COPY_STACKS - est utilisé pour copier les piles également, sans cela, nous
cloner les données et mettre à zéro les piles, avec lui on copie les piles et le nouveau perl
L'interpréteur est prêt à s'exécuter exactement au même point que le précédent. le
le code pseudo-fork utilise COPY_STACKS alors que les threads->create ne le font pas.

CLONEf_KEEP_PTR_TABLE - perl_clone conserve une ptr_table avec le pointeur de l'ancien
variable comme clé et la nouvelle variable comme valeur, cela lui permet de vérifier si
quelque chose a été cloné et ne le clonez pas à nouveau, mais utilisez simplement la valeur et
augmenter le refcount. Si KEEP_PTR_TABLE n'est pas défini, perl_clone tuera le
ptr_table en utilisant la fonction "ptr_table_free(PL_ptr_table); PL_ptr_table = NULL;",
la raison de le garder est si vous voulez dupliquer certaines de vos propres variables qui sont
en dehors des analyses perl du graphe, un exemple de ce code se trouve dans threads.xs create.

CLONEf_CLONE_HOST - C'est une chose win32, il est ignoré sur unix, il dit à perls
code win32host (qui est c++) pour se cloner, ceci est nécessaire sur win32 si vous voulez
pour exécuter deux threads en même temps, si vous voulez juste faire des choses dans un
séparez l'interpréteur perl, puis jetez-le et revenez à l'original,
vous n'avez rien à faire.

PerlInterpreter* perl_clone(
Interpréteur Perl *proto_perl,
drapeaux UV
)

Temps de compilation portée crochets

BhkDISABLE
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Désactivez temporairement une entrée dans cette structure BHK, en désactivant le
drapeau. qui est un jeton de préprocesseur indiquant quelle entrée désactiver.

void BhkDISABLE(BHK *hk, qui)

BhkENABLE
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Réactivez une entrée dans cette structure BHK, en définissant l'indicateur approprié. qui
est un jeton de préprocesseur indiquant quelle entrée activer. Cela affirmera (sous
-DDEBUGING) si l'entrée ne contient pas de pointeur valide.

void BhkENABLE(BHK *hk, qui)

BhkENTRY_set
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Définissez une entrée dans la structure BHK et définissez les indicateurs pour indiquer qu'elle est valide.
qui est un jeton de prétraitement indiquant quelle entrée définir. Le type de ptr
dépend de l'entrée.

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

blockhook_register
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Enregistrez un ensemble de crochets à appeler lorsque la portée lexicale de Perl change à
temps de compilation. Voir « Hooks de portée au moment de la compilation » dans perlguts.

REMARQUE : cette fonction doit être explicitement appelée en tant que Perl_blockhook_register avec un
un paramètre THX_.

void Perl_blockhook_register(pTHX_BHK *hk)

COP Indice Des hachis

cophh_2hv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Génère et renvoie un hachage Perl standard représentant l'ensemble complet de clé/valeur
paires dans le hachage des indices de flic coph. drapeaux est actuellement inutilisé et doit être égal à zéro.

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

copie_coph
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Faites et retournez une copie complète du hachage des indices de flic coph.

COPHH * cophh_copie(COPHH *cophh)

cophh_delete_pv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_delete_pvn", mais prend une chaîne à zéro terminal au lieu d'un
paire chaîne/longueur.

COPHH * cophh_delete_pv(const COPHH *cophh,
const char *clé, hachage U32,
drapeaux U32)

cophh_delete_pvn
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Supprimer une clé et sa valeur associée du hachage des astuces de flic coph, et retourne
le hachage modifié. Le pointeur de hachage renvoyé n'est en général pas le même que le
pointeur de hachage qui a été transmis. Le hachage d'entrée est consommé par la fonction, et
le pointeur vers celui-ci ne doit pas être utilisé par la suite. Utilisez "cophh_copy" si vous avez besoin
les deux hachages.

La clé est spécifiée par clépv et Keylen. Si drapeaux a le bit "COPHH_KEY_UTF8"
défini, les octets clés sont interprétés comme UTF-8, sinon ils sont interprétés comme
Latin-1. hachage est un hachage précalculé de la chaîne de clé, ou zéro s'il n'a pas été
précalculé.

COPHH * cophh_delete_pvn(COPHH *cophh,
caractère const *keypv,
Keylen STRLEN, hachage U32,
drapeaux U32)

cophh_delete_pvs
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_delete_pvn", mais prend une chaîne littérale au lieu d'une chaîne/longueur
paire, et pas de hachage précalculé.

COPHH * cophh_delete_pvs(const COPHH *cophh,
const char *clé, drapeaux U32)

cophh_delete_sv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_delete_pvn", mais prend un scalaire Perl au lieu d'une paire chaîne/longueur.

COPHH * cophh_delete_sv(const COPHH *cophh, SV *clé,
hachage U32, drapeaux U32)

cophh_fetch_pv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_fetch_pvn", mais prend une chaîne à zéro terminal au lieu d'un
paire chaîne/longueur.

SV * cophh_fetch_pv(const COPHH *cophh,
const char *clé, hachage U32,
drapeaux U32)

cophh_fetch_pvn
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Recherchez l'entrée dans le hachage des indices de flic coph avec la clé spécifiée par clépv et
Keylen. Si drapeaux a le bit "COPHH_KEY_UTF8" défini, les octets clés sont interprétés
comme UTF-8, sinon ils sont interprétés comme Latin-1. hachage est un hachage précalculé
de la chaîne de clé, ou zéro s'il n'a pas été précalculé. Renvoie un mortel
copie scalaire de la valeur associée à la clé, ou &PL_sv_placeholder s'il y a
aucune valeur n'est associée à la clé.

SV * cophh_fetch_pvn(const COPHH *cophh,
caractère const *keypv,
Keylen STRLEN, hachage U32,
drapeaux U32)

cophh_fetch_pvs
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_fetch_pvn", mais prend une chaîne littérale au lieu d'une chaîne/longueur
paire, et pas de hachage précalculé.

SV * cophh_fetch_pvs(const COPHH *cophh,
const char *clé, drapeaux U32)

cophh_fetch_sv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_fetch_pvn", mais prend un scalaire Perl au lieu d'une paire chaîne/longueur.

SV * cophh_fetch_sv(const COPHH *cophh, SV *clé,
hachage U32, drapeaux U32)

coph_free
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Jeter le hachage des indices de flic coph, libérant toutes les ressources qui lui sont associées.

annuler cophh_free(COPHH *cophh)

cophh_new_empty
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Générez et renvoyez un nouveau hachage d'indices de flic ne contenant aucune entrée.

COPHH * cophh_new_empty()

cophh_store_pv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_store_pvn", mais prend une chaîne terminée par zéro au lieu d'un
paire chaîne/longueur.

COPHH * cophh_store_pv(const COPHH *cophh,
const char *clé, hachage U32,
SV *valeur, drapeaux U32)

cophh_store_pvn
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Stocke une valeur, associée à une clé, dans le hachage des astuces de flic coph, et retourne
le hachage modifié. Le pointeur de hachage renvoyé n'est en général pas le même que le
pointeur de hachage qui a été transmis. Le hachage d'entrée est consommé par la fonction, et
le pointeur vers celui-ci ne doit pas être utilisé par la suite. Utilisez "cophh_copy" si vous avez besoin
les deux hachages.

La clé est spécifiée par clépv et Keylen. Si drapeaux a le bit "COPHH_KEY_UTF8"
défini, les octets clés sont interprétés comme UTF-8, sinon ils sont interprétés comme
Latin-1. hachage est un hachage précalculé de la chaîne de clé, ou zéro s'il n'a pas été
précalculé.

Plus-value est la valeur scalaire à stocker pour cette clé. Plus-value est copié par ce
fonction, qui ne s'approprie donc aucune référence à celle-ci, et plus tard
les modifications apportées au scalaire ne seront pas reflétées dans la valeur visible dans les conseils de flic
hacher. Les types complexes de scalaires ne seront pas stockés avec intégrité référentielle, mais
sera contraint à des ficelles.

COPHH * coph_store_pvn(COPHH *cophh, const char *keypv,
Keylen STRLEN, hachage U32,
SV *valeur, drapeaux U32)

cophh_store_pvs
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_store_pvn", mais prend une chaîne littérale au lieu d'une chaîne/longueur
paire, et pas de hachage précalculé.

COPHH * cophh_store_pvs(const COPHH *cophh,
const char *clé, SV *valeur,
drapeaux U32)

cophh_store_sv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "cophh_store_pvn", mais prend un scalaire Perl au lieu d'une paire chaîne/longueur.

COPHH * cophh_store_sv(const COPHH *cophh, SV *clé,
hachage U32, valeur SV *, drapeaux U32)

COP Indice en cours

cop_hints_2hv
Génère et renvoie un hachage Perl standard représentant l'ensemble complet de conseils
entrées dans le flic flic. drapeaux est actuellement inutilisé et doit être égal à zéro.

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

cop_hints_fetch_pv
Comme "cop_hints_fetch_pvn", mais prend une chaîne terminée par zéro au lieu d'un
paire chaîne/longueur.

SV * cop_hints_fetch_pv (const COP * cop,
const char *clé, hachage U32,
drapeaux U32)

cop_hints_fetch_pvn
Recherchez l'entrée d'indice dans le flic flic avec la clé spécifiée par clépv et Keylen.
If drapeaux a le bit "COPHH_KEY_UTF8" défini, les octets clés sont interprétés comme
UTF-8, sinon ils sont interprétés comme Latin-1. hachage est un hachage précalculé de
la chaîne de clé, ou zéro si elle n'a pas été précalculée. Renvoie un scalaire mortel
copie de la valeur associée à la clé, ou &PL_sv_placeholder s'il n'y en a pas
valeur associée à la clé.

SV * cop_hints_fetch_pvn (const COP * cop,
caractère const *keypv,
Keylen STRLEN, hachage U32,
drapeaux U32)

cop_hints_fetch_pvs
Comme "cop_hints_fetch_pvn", mais prend une chaîne littérale au lieu d'une chaîne/longueur
paire, et pas de hachage précalculé.

SV * cop_hints_fetch_pvs (const COP * cop,
const char *clé, drapeaux U32)

cop_hints_fetch_sv
Comme "cop_hints_fetch_pvn", mais prend un scalaire Perl au lieu d'une chaîne/longueur
paire.

SV * cop_hints_fetch_sv(const COP *cop, SV *clé,
hachage U32, drapeaux U32)

Personnalisé Les opérateurs

custom_op_register
Enregistrez une opération personnalisée. Voir "Opérateurs personnalisés" dans perlguts.

REMARQUE : cette fonction doit être explicitement appelée en tant que Perl_custom_op_register avec un
un paramètre THX_.

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

personnalisé_op_xop
Renvoie la structure XOP pour une opération personnalisée donnée. Cette macro doit être considérée
interne à OP_NAME et aux autres macros d'accès : utilisez-les à la place. Cette macro
appelle une fonction. Avant 5.19.6, cela était implémenté en tant que fonction.

REMARQUE : cette fonction doit être explicitement appelée en tant que Perl_custom_op_xop avec un aTHX_
paramètre.

const XOP * Perl_custom_op_xop(pTHX_ const OP *o)

XopDISABLE
Désactivez temporairement un membre du XOP en désactivant le drapeau approprié.

void XopDISABLE(XOP *xop, qui)

XopENABLE
Réactivez un membre du XOP qui a été désactivé.

void XopENABLE(XOP *xop, qui)

XopenENTRY
Renvoie un membre de la structure XOP. qui est un jeton cpp indiquant quelle entrée
rendre. Si le membre n'est pas défini, cela renverra une valeur par défaut. Le retour
le type dépend de qui. Cette macro évalue ses arguments plusieurs fois. Si vous
utilisez "Perl_custom_op_xop" pour récupérer un "XOP *" à partir d'un "OP *", utilisez le plus
efficace "XopENTRYCUSTOM" à la place.

XopENTRY(XOP *xop, qui)

XopENTRYPERSONNALISÉ
Exactement comme "XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_ o), qui)" mais plus
efficace. le qui paramètre est identique à "XopENTRY".

XopENTRYCUSTOM(const OP *o, qui)

XopENTRY_set
Définissez un membre de la structure XOP. qui est un jeton cpp indiquant quelle entrée
ensemble. Voir "Opérateurs personnalisés" dans perlguts pour plus de détails sur les membres disponibles
et comment ils sont utilisés. Cette macro évalue son argument plus d'une fois.

void XopENTRY_set(XOP *xop, qui, valeur)

XopFLAGS
Renvoyez les drapeaux du XOP.

U32 XopFLAGS(XOP *xop)

CV Manipulation Les fonctions

Cette section documente les fonctions permettant de manipuler les CV qui sont des valeurs de code ou des sous-routines.
Pour plus d'informations, voir perlguts.

appelant_cx
L'équivalent du XSUB-writer de votre interlocuteur(). La structure "PERL_CONTEXT" renvoyée
peut être interrogé pour retrouver toutes les informations renvoyées à Perl par "l'appelant".
Notez que les XSUB n'obtiennent pas de cadre de pile, donc "caller_cx(0, NULL)" retournera
informations pour le code Perl immédiatement environnant.

Cette fonction ignore les appels automatiques à &DB::sub effectués pour le compte du
débogueur. Si le cadre de pile demandé était un sous appelé par "DB::sub", le retour
value sera le cadre de l'appel à "DB::sub", car il a la bonne ligne
nombre/etc. pour le site d'appel. Si dbcxp n'est pas "NULL", il sera défini sur un
pointeur vers le cadre du sous-appel lui-même.

const PERL_CONTEXT * appelant_cx(
niveau I32,
const PERL_CONTEXT **dbcxp
)

CvSTASH Renvoie la cache du CV. Une cache est le hachage de la table des symboles, contenant le
variables de portée package dans le package où la sous-routine a été définie. Pour
plus d'informations, voir perlguts.

Cela a également une utilisation spéciale avec les sous-marins XS AUTOLOAD. Voir « Chargement automatique avec les XSUB »
en perlguts.

HV* CvSTASH(CV* cv)

trouver_runcv
Localisez le CV correspondant au sous- ou eval en cours d'exécution. Si db_seqp est
non_null, ignorez les CV qui se trouvent dans le package DB et remplissez *db_seqp avec le flic
numéro de séquence au moment où le code DB:: a été entré. (Ceci permet
débogueurs à évaluer dans la portée du point d'arrêt plutôt que dans la portée du
débogueur lui-même.)

CV* find_runcv(U32 *db_seqp)

get_cv Utilise "strlen" pour obtenir la longueur de "nom", puis appelle "get_cvn_flags".

REMARQUE : la forme perl_ de cette fonction est dépréciée.

CV* get_cv(const char* nom, indicateurs I32)

get_cvn_flags
Renvoie le CV du sous-programme Perl spécifié. des "drapeaux" sont passés à
"gv_fetchpvn_flags". Si "GV_ADD" est défini et que le sous-programme Perl n'existe pas
alors il sera déclaré (ce qui a le même effet que de dire "sous-nom ;"). Si
"GV_ADD" n'est pas défini et le sous-programme n'existe pas, alors NULL est renvoyé.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

CV* get_cvn_flags(const char* nom, len STRLEN,
drapeaux I32)

Débogage Utilitaires

dump_all
Vide l'intégralité de l'optree du programme en cours à partir de "PL_main_root" vers
"STDERR". Vide également les optrees pour tous les sous-programmes visibles dans "PL_defstash".

annuler dump_all()

dump_packsubs
Vide les optrees pour toutes les sous-routines visibles dans "stash".

void dump_packsubs (const HV * réserve)

op_dump Vide l'optree à partir de l'OP "o" vers "STDERR".

void op_dump (const OP *o)

sv_dump Vide le contenu d'un SV dans le descripteur de fichier "STDERR".

Pour un exemple de sa sortie, voir Devel::Peek.

vide sv_dump(SV* sv)

Écran et Déverser fonctions

pv_affichage
Similaire à

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

sauf qu'un "\0" supplémentaire sera ajouté à la chaîne lorsque len > cur et
pv[cur] est "\0".

Notez que la chaîne finale peut comporter jusqu'à 7 caractères de plus que pvlim.

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

pv_évasion
Échappe au plus les premiers caractères "count" de pv et met les résultats dans dsv tels
que la taille de la chaîne échappée ne dépassera pas les caractères "max" et ne
contenir des séquences d'échappement incomplètes. Le nombre d'octets échappés sera
renvoyé dans le paramètre STRLEN *échappé s'il n'est pas nul. Quand le dsv
le paramètre est nul, aucun échappement ne se produit réellement, mais le nombre d'octets qui
être échappé s'il n'était pas nul sera calculé.

Si flags contient PERL_PV_ESCAPE_QUOTE, alors tout guillemet double dans la chaîne sera
également être échappé.

Normalement, le SV sera effacé avant que la chaîne d'échappement ne soit préparée, mais lorsque
PERL_PV_ESCAPE_NOCLEAR est défini, cela ne se produira pas.

Si PERL_PV_ESCAPE_UNI est défini, la chaîne d'entrée est traitée comme UTF-8 si
PERL_PV_ESCAPE_UNI_DETECT est défini, puis la chaîne d'entrée est analysée à l'aide
"is_utf8_string()" pour déterminer s'il s'agit d'UTF-8.

Si PERL_PV_ESCAPE_ALL est défini, tous les caractères d'entrée seront générés en utilisant "\x01F1"
le style s'échappe, sinon si PERL_PV_ESCAPE_NONASCII est défini, seuls les caractères non-ASCII
sera échappé en utilisant ce style ; sinon, seuls les caractères supérieurs à 255 le seront
échappé; d'autres caractères non imprimables utiliseront des motifs d'échappement octaux ou communs comme
"\n". Sinon, si PERL_PV_ESCAPE_NOBACKSLASH alors tous les caractères inférieurs à 255 seront
traités comme imprimables et seront générés sous forme de littéraux.

Si PERL_PV_ESCAPE_FIRSTCHAR est défini, seul le premier caractère de la chaîne sera
échappé, quel que soit le max. Si la sortie doit être en hexadécimal, alors elle sera
renvoyé sous la forme d'une séquence hexadécimale simple. Ainsi, la sortie sera soit un seul caractère,
une séquence d'échappement octale, une échappement spéciale comme "\n" ou une valeur hexadécimale.

Si PERL_PV_ESCAPE_RE est défini, le caractère d'échappement utilisé sera un '%' et non un
'\\'. C'est parce que les regex contiennent très souvent des séquences backslashées, alors que
'%' n'est pas un caractère particulièrement courant dans les motifs.

Renvoie un pointeur vers le texte échappé détenu par dsv.

char* pv_escape(SV *dsv, char const * chaîne const,
const STRLEN compte, const STRLEN max,
STRLEN * const échappé,
drapeaux const U32)

pv_jolie
Convertit une chaîne en quelque chose de présentable, en gérant l'échappement via pv_escape()
et à l'appui des guillemets et des points de suspension.

Si l'indicateur PERL_PV_PRETTY_QUOTE est défini, le résultat sera entre guillemets avec
tous les guillemets doubles dans la chaîne se sont échappés. Sinon si le PERL_PV_PRETTY_LTGT
flag est défini, puis le résultat est entouré de crochets angulaires.

Si l'indicateur PERL_PV_PRETTY_ELLIPSES est défini et que tous les caractères de la chaîne n'étaient pas
sortie, une ellipse "..." sera ajoutée à la chaîne. Notez que ce
arrive APRÈS qu'il a été cité.

Si start_color est non nul, il sera inséré après le guillemet d'ouverture (si
il y en a un) mais avant le texte échappé. Si end_color n'est pas nul, il le fera
être inséré après le texte échappé mais avant les guillemets ou les points de suspension.

Renvoie un pointeur vers le texte embelli tel que détenu par dsv.

char* pv_pretty(SV *dsv, char const * chaîne const,
const STRLEN compte, const STRLEN max,
char const * const start_color,
char const * const end_color,
drapeaux const U32)

Enrobage Les fonctions

cv_clone
Clonez un CV, en faisant une fermeture lexicale. proto fournit le prototype du
fonction : son code, la structure du tampon et d'autres attributs. Le prototype est
combinée à une capture des lexiques externes auxquels le code fait référence, qui sont
extrait de l'instance en cours d'exécution du code immédiatement environnant.

CV * cv_clone(CV *proto)

cv_name Renvoie un SV contenant le nom du CV, principalement à utiliser dans les rapports d'erreurs.
Le CV peut en fait être un GV à la place, auquel cas le SV renvoyé contient les GV
Nom. Tout autre qu'un GV ou un CV est traité comme une chaîne contenant déjà le
sous-nom, mais cela pourrait changer à l'avenir.

Un SV peut être passé comme deuxième argument. Si c'est le cas, le nom lui sera attribué
et il sera retourné. Sinon, le SV retourné sera un nouveau mortel.

Si la drapeaux inclure CV_NAME_NOTQUAL, le nom du package ne sera pas inclus.
Si le premier argument n'est ni un CV ni un GV, ce drapeau est ignoré (sous réserve de
monnaie).

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

cv_undef
Effacez tous les composants actifs d'un CV. Cela peut se produire soit par un
explicite "undef &foo", ou par le nombre de références allant à zéro. Dans l'ancien
cas, nous gardons le pointeur CvOUTSIDE, afin que tous les enfants anonymes puissent toujours
suivre toute la chaîne de portée lexicale.

annuler cv_undef(CV* cv)

find_rundefsv
Recherchez et renvoyez la variable nommée $_ dans la portée lexicale du
fonction en cours d'exécution. Cela peut être un $_ lexical, ou sera autrement le
une mondiale.

SV * find_rundefsv()

find_rundefsvoffset
DÉCONSEILLÉ ! Il est prévu de supprimer cette fonction d'une future version de Perl.
Ne l'utilisez pas pour un nouveau code ; le supprimer du code existant.

Trouver la position du lexical $_ dans le pad du cours en cours d'exécution
une fonction. Renvoie l'offset dans le pad courant, ou "NOT_IN_PAD" s'il n'y a pas
lexical $_ dans la portée (auquel cas la portée globale doit être utilisée à la place).
"find_rundefsv" est probablement plus pratique.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

PADOFFSET find_rundefsvoffset()

intro_mon
"Introduire" "mes" variables à l'état visible. Ceci est appelé lors de l'analyse à
la fin de chaque instruction pour rendre les variables lexicales visibles aux
Déclarations.

U32 intro_my()

module_chargement
Charge le module dont le nom est pointé par la partie de chaîne de nom. Noter que
le nom réel du module, et non son nom de fichier, doit être indiqué. Par exemple, "Foo::Bar" à la place
de "Foo/Bar.pm". les indicateurs peuvent être n'importe lequel de PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT ou
PERL_LOADMOD_IMPORT_OPS (ou 0 pour aucun indicateur). ver, si spécifié et non NULL,
fournit une sémantique de version similaire à "use Foo::Bar VERSION". L'optionnel
les arguments SV* de fin peuvent être utilisés pour spécifier des arguments au module importer()
méthode, similaire à "utiliser Foo::Bar VERSION LIST". Ils doivent être résiliés par un
pointeur NULL final. Notez que cette liste ne peut être omise que lorsque le
L'indicateur PERL_LOADMOD_NOIMPORT a été utilisé. Sinon au moins un seul NULL
pointeur pour désigner la liste d'importation par défaut est requis.

Le nombre de références pour chaque paramètre "SV*" spécifié est décrémenté.

void load_module (drapeaux U32, nom SV*, ver SV*, ...)

nouveauPADNAMELIST
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Crée une nouvelle liste de noms de pad. "max" est l'indice le plus élevé pour lequel l'espace est
alloués.

PADNAMELIST * nouveauPADNAMELIST(size_t max)

nouveauPADNAMEextérieur
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Construit et renvoie un nouveau nom de pastille. N'utilisez cette fonction que pour les noms qui
se référer à des lexiques externes. (Voir aussi "newPADNAMEpvn".) extérieur est le nom du tampon extérieur
que celui-ci reflète. Le nom de pad renvoyé a déjà l'indicateur PADNAMEt_OUTER
défini.

PADNAME * nouveauPADNAMEouter(PADNAME *outer)

nouveauPADNAMEpvn
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Construit et renvoie un nouveau nom de pastille. s doit être une chaîne UTF8. Ne pas utiliser ce
pour les noms de blocs qui pointent vers des lexiques externes. Voir "newPADNAMEouter".

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

crochet
Stub qui fournit un crochet de thread pour perl_destruct lorsqu'il n'y a pas de threads.

int notthreadhook()

padnamelist_fetch
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Récupère le nom du pad à partir de l'index donné.

PADNAME * padnamelist_fetch (PADNAMELIST * pnl,
clé SSize_t)

padnamelist_store
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Stocke le nom du pad (qui peut être nul) à l'index donné, libérant tout
le nom du pad dans cet emplacement.

PADNAME ** padnamelist_store(PADNAMELIST *pnl,
Clé SSize_t, PADNAME *val)

pad_add_anon
Alloue une place dans le pad en cours de compilation (via "pad_alloc") pour un
fonction anonyme qui a une portée lexicale à l'intérieur de la compilation en cours
une fonction. La fonction fonction est lié au pad, et son lien "CvOUTSIDE" vers
la portée externe est affaiblie pour éviter une boucle de référence.

Un compte de référence est volé, vous devrez donc peut-être faire "SvREFCNT_inc(func)".

type d'option devrait être un opcode indiquant le type d'opération que l'entrée du pad est
soutenir. Cela n'affecte pas la sémantique opérationnelle, mais est utilisé pour le débogage.

PADOFFSET pad_add_anon(CV *fonc, I32 optype)

pad_add_name_pv
Exactement comme "pad_add_name_pvn", mais prend une chaîne terminée par zéro au lieu d'un
paire chaîne/longueur.

PADOFFSET pad_add_name_pv(const char *nom, drapeaux U32,
HV *typestash, HV *ourstash)

pad_add_name_pvn
Alloue une place dans le pad en cours de compilation à une variable lexicale nommée.
Stocke le nom et d'autres métadonnées dans la partie nom du pad, et rend
préparations pour gérer la portée lexicale de la variable. Renvoie le décalage du
emplacement de pad alloué.

nompv/Namelen spécifiez le nom de la variable, y compris le sceau principal. Si dactylographier
est non nul, le nom est pour un lexique typé, et cela identifie le type. Si
notre cachette est non nul, c'est une référence lexicale à une variable de package, et ceci
identifie le colis. Les drapeaux suivants peuvent être combinés OU :

padadd_OUR spécifie de manière redondante s'il s'agit d'un package var
La variable padadd_STATE conservera la valeur de manière persistante
padadd_NO_DUP_CHECK ignorer la vérification de l'ombrage lexical

PADOFFSET pad_add_name_pvn(const char *namepv,
Noms STRLEN, drapeaux U32,
HV *typestash, HV *ourstash)

pad_add_name_sv
Exactement comme "pad_add_name_pvn", mais prend la chaîne de nom sous la forme d'un SV
au lieu d'une paire chaîne/longueur.

PADOFFSET pad_add_name_sv(SV *nom, drapeaux U32,
HV *typestash, HV *ourstash)

pad_alloc
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Alloue une place dans le pad en cours de compilation, renvoyant le décalage du
emplacement de pad alloué. Aucun nom n'est initialement attaché à l'emplacement du pad. typetmp est une
ensemble d'indicateurs indiquant le type d'entrée de pad requis, qui sera défini dans le
valeur SV pour l'entrée pad allouée :

Variable lexicale nommée SVs_PADMY ("mon", "notre", "état")
SVs_PADTMP magasin temporaire sans nom
Constante SVf_READONLY partagée entre les niveaux de récursivité

"SVf_READONLY" n'est supporté ici que depuis perl 5.20. Pour travailler avec plus tôt
également, utilisez "SVf_READONLY|SVs_PADTMP". "SVf_READONLY" ne provoque pas
le SV dans l'emplacement du pad doit être marqué en lecture seule, mais indique simplement à "pad_alloc" que
it vont être mis en lecture seule (par l'appelant), ou du moins devrait être traité comme tel.

type d'option devrait être un opcode indiquant le type d'opération que l'entrée du pad est
soutenir. Cela n'affecte pas la sémantique opérationnelle, mais est utilisé pour le débogage.

PADOFFSET pad_alloc (type d'option I32, type de tmp U32)

pad_findmy_pv
Exactement comme "pad_findmy_pvn", mais prend une chaîne terminée par zéro au lieu d'un
paire chaîne/longueur.

PADOFFSET pad_findmy_pv(const char *nom, drapeaux U32)

pad_findmy_pvn
Étant donné le nom d'une variable lexicale, trouver sa position dans le fichier en cours de compilation
tampon. nompv/Namelen spécifiez le nom de la variable, y compris le sceau principal. drapeaux
est réservé et doit être égal à zéro. S'il n'est pas dans le pad actuel mais apparaît dans le
pad de n'importe quelle portée lexicale, puis une pseudo-entrée pour elle est ajoutée dans le
tampon actuel. Renvoie le décalage dans le pad actuel, ou "NOT_IN_PAD" si tel n'est pas le cas
lexical est dans la portée.

PADOFFSET pad_findmy_pvn(const char *namepv,
Nom STRLEN, drapeaux U32)

pad_findmy_sv
Exactement comme "pad_findmy_pvn", mais prend la chaîne de nom sous la forme d'un SV
au lieu d'une paire chaîne/longueur.

PADOFFSET pad_findmy_sv(SV *nom, drapeaux U32)

pad_setsv
Définir la valeur au décalage po dans le pad actuel (de compilation ou d'exécution). Utilisez le
macro PAD_SETSV() plutôt que d'appeler cette fonction directement.

void pad_setsv(PADOFFSET po, SV *sv)

pad_sv Récupère la valeur au décalage po dans le pad actuel (de compilation ou d'exécution). Utiliser des macros
PAD_SV au lieu d'appeler directement cette fonction.

SV * pad_sv(PADOFFSETpo)

pad_tidy
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Rangez un bloc en fin de compilation du code auquel il appartient. Travaux
exécutées ici sont : enlever la plupart des éléments des blocs des prototypes anonsub ; donne-le
une @_; marquer les temporaires comme tels. type indique le type de sous-programme :

padtidy_SUB sous-routine ordinaire
padtidy_SUBCLONE prototype pour la fermeture lexicale
format padtidy_FORMAT

void pad_tidy (type padtidy_type)

perl_alloc
Alloue un nouvel interpréteur Perl. Voir perlembed.

Interpréteur Perl* perl_alloc()

perl_construct
Initialise un nouvel interpréteur Perl. Voir perlembed.

void perl_construct(PerlInterpreter *my_perl)

perl_destruct
Arrête un interpréteur Perl. Voir perlembed.

int perl_destruct(PerlInterpreter *mon_perl)

perl_free
Libère un interpréteur Perl. Voir perlembed.

void perl_free(PerlInterpreter *my_perl)

perl_parse
Demande à un interpréteur Perl d'analyser un script Perl. Voir perlembed.

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

perl_run
Demande à un interpréteur Perl de s'exécuter. Voir perlembed.

int perl_run(PerlInterpreter *my_perl)

exiger_pv
Indique à Perl d'"exiger" le fichier nommé par l'argument chaîne. C'est analogue à
le code Perl "eval "require '$file'"". C'est même mis en œuvre de cette façon; envisager
en utilisant load_module à la place.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

void require_pv (const char* pv)

Exception Maniabilité (Facile) Macros

dXCPT Configurez les variables locales nécessaires pour la gestion des exceptions. Voir « Gestion des exceptions »
en perlguts.

dXCPT ;

XCPT_CATCH
Introduit un bloc catch. Voir « Gestion des exceptions » dans perlguts.

XCPT_RETHRROW
Relance une exception précédemment interceptée. Voir « Gestion des exceptions » dans perlguts.

XCPT_RETHROW ;

XCPT_TRY_END
Termine un bloc d'essai. Voir « Gestion des exceptions » dans perlguts.

XCPT_TRY_START
Démarre un bloc d'essai. Voir « Gestion des exceptions » dans perlguts.

Global Variables

Ces variables sont globales à l'ensemble d'un processus. Ils sont partagés entre tous les interprètes
et tous les threads d'un processus.

PL_vérifier
Tableau, indexé par opcode, de fonctions qui seront appelées pour la phase "check"
de la construction d'optree lors de la compilation du code Perl. Pour la plupart (mais pas tous) les types
d'op, une fois que l'op a été initialement construit et rempli d'ops enfants, il
être filtré par la fonction de contrôle référencée par l'élément approprié de
ce tableau. Le nouvel op est transmis comme seul argument à la fonction de vérification,
et la fonction de vérification renvoie l'opération terminée. La fonction de contrôle peut (comme le
le nom l'indique) vérifiez l'op pour la validité et les erreurs de signal. Il peut également
initialiser ou modifier des parties des opérations, ou effectuer une chirurgie plus radicale telle que
ajouter ou supprimer des opérations enfants, ou même jeter l'opération et renvoyer une opération différente
à sa place.

Ce tableau de pointeurs de fonction est un endroit pratique pour se connecter à la compilation
traiter. Un module XS peut mettre sa propre fonction de vérification personnalisée à la place de l'un des
les standards, pour influencer la compilation d'un type particulier d'op.
Cependant, une fonction de contrôle personnalisé ne doit jamais remplacer complètement un contrôle standard
fonction (ou même une fonction de vérification personnalisée d'un autre module). Un module
modifier la vérification doit à la place envelopper la fonction de vérification préexistante. Une coutume
La fonction de vérification doit être sélective quant au moment d'appliquer son comportement personnalisé. Dans le
cas habituel où il décide de ne rien faire de spécial avec un op, il doit enchaîner
la fonction op préexistante. Les fonctions de contrôle sont ainsi liées dans une chaîne, avec le
le vérificateur de base du noyau à la fin.

Pour la sécurité des threads, les modules ne doivent pas écrire directement dans ce tableau. Au lieu de cela, utilisez
la fonction "wrap_op_checker".

PL_keyword_plugin
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Pointeur de fonction, pointant sur une fonction utilisée pour gérer les mots-clés étendus. le
la fonction doit être déclarée comme

int mot-clé_plugin_function (pTHX_
char *word_ptr, STRLEN keyword_len,
OP**op_ptr)

La fonction est appelée depuis le tokeniser, chaque fois qu'un mot-clé possible est vu.
"keyword_ptr" pointe sur le mot dans le tampon d'entrée de l'analyseur, et "keyword_len"
donne sa longueur; il n'est pas terminé par un zéro. La fonction est censée examiner
le mot, et éventuellement un autre état tel que %^H, pour décider s'il veut
traitez-le comme un mot-clé étendu. Si ce n'est pas le cas, la fonction doit retourner
"KEYWORD_PLUGIN_DECLINE", et le processus normal de l'analyseur continuera.

Si la fonction veut gérer le mot-clé, elle doit d'abord analyser n'importe quoi
suivant le mot-clé qui fait partie de la syntaxe introduite par le mot-clé. Voir
"Interface Lexer" pour plus de détails.

Lorsqu'un mot-clé est manipulé, la fonction du plugin doit construire un arbre de "OP"
structures, représentant le code qui a été analysé. La racine de l'arbre doit être
stocké dans *op_ptr. La fonction renvoie alors une constante indiquant la syntaxe
rôle du construit qu'il a parsé : "KEYWORD_PLUGIN_STMT" s'il s'agit d'un
instruction complète, ou "KEYWORD_PLUGIN_EXPR" s'il s'agit d'une expression. Notez qu'un
La construction d'instruction ne peut pas être utilisée dans une expression (sauf via "do BLOCK" et
similaire), et une expression n'est pas une déclaration complète (elle nécessite au moins un
point-virgule de fin).

Lorsqu'un mot-clé est manipulé, la fonction du plugin peut également avoir un côté (au moment de la compilation)
effets. Il peut modifier "%^H", définir des fonctions, etc. Typiquement, si côté
les effets sont le but principal d'un gestionnaire, il ne souhaite pas générer d'opérations pour
être inclus dans la compilation normale. Dans ce cas, il est encore nécessaire de
fournir un arbre d'opérations, mais il suffit de générer une seule opération nulle.

C'est ainsi que la fonction *PL_keyword_plugin doit se comporter globalement.
Classiquement, cependant, on ne remplace pas complètement le gestionnaire existant
une fonction. Au lieu de cela, prenez une copie de "PL_keyword_plugin" avant d'attribuer le vôtre
pointeur de fonction vers celui-ci. Votre fonction de gestionnaire doit rechercher les mots-clés qu'il est
intéressés et les gérer. S'il n'est pas intéressé, il doit appeler le
fonction de plugin enregistrée, en transmettant les arguments qu'il a reçus. Ainsi
"PL_keyword_plugin" pointe en fait vers une chaîne de fonctions de gestionnaire, toutes
avoir la possibilité de gérer des mots-clés, et seulement la dernière fonction de la chaîne
(intégré au noyau Perl) renverra normalement "KEYWORD_PLUGIN_DECLINE".

GV Les fonctions

Un GV est une structure qui correspond à un typeglob Perl, c'est-à-dire *foo. C'est une structure
qui contient un pointeur vers un scalaire, un tableau, un hachage, etc., correspondant à $foo, @foo, %foo.

Les GV se trouvent généralement sous forme de valeurs dans des caches (hachages de table de symboles) où Perl stocke ses
variables globales.

GvAV Renvoie l'AV du GV.

AV* GVAV(GV* GV)

GvCV Renvoie le CV du GV.

CV* GVCV(GV* GV)

GvHV Renvoyez le HV du GV.

HV* GvHV(GV* GV)

GvSV Renvoie le SV du GV.

SV* GvSV(GV* gv)

gv_const_sv
Si "gv" est un typeglob dont l'entrée de sous-programme est une constante sous éligible pour
inlining, ou "gv" est une référence d'espace réservé qui serait promue à un tel
typeglob, puis renvoie la valeur renvoyée par le sub. Sinon, renvoie NULL.

SV* gv_const_sv(GV* gv)

gv_fetchmeth
Comme "gv_fetchmeth_pvn", mais il manque un paramètre flags.

GV* gv_fetchmeth(HV* stash, const char* nom,
lentille STRLEN, niveau I32)

gv_fetchmethod_autoload
Renvoie le glob qui contient le sous-programme à appeler pour invoquer la méthode sur le
"planque". En fait, en présence de chargement automatique, cela peut être le glob pour
"AUTOCHARGE". Dans ce cas, la variable $AUTOLOAD correspondante est déjà configurée.

Le troisième paramètre de "gv_fetchmethod_autoload" détermine si AUTOLOAD
la recherche est effectuée si la méthode donnée n'est pas présente : non nul signifie oui, regardez
pour CHARGEMENT AUTOMATIQUE ; zéro signifie non, ne cherchez pas AUTOLOAD. Appeler "gv_fetchmethod" est
équivalent à appeler "gv_fetchmethod_autoload" avec un "autoload" différent de zéro
paramètre.

Ces fonctions accordent le jeton "SUPER" comme préfixe du nom de la méthode. Notez que si
vous souhaitez conserver le glob renvoyé pendant longtemps, vous devez vérifier qu'il est
"AUTOLOAD", car plus tard l'appel peut charger un sous-programme différent en raison
à $AUTOLOAD en changeant sa valeur. Utilisez le glob créé comme effet secondaire pour faire
ce.

Ces fonctions ont les mêmes effets secondaires que "gv_fetchmeth" avec "level==0". le
l'avertissement contre le passage du GV renvoyé par "gv_fetchmeth" à "call_sv" s'applique
également à ces fonctions.

GV* gv_fetchmethod_autoload(stockage HV*,
nom du caractère const*,
I32 chargement automatique)

gv_fetchmeth_autoload
Il s'agit de l'ancienne forme de "gv_fetchmeth_pvn_autoload", qui n'a pas de paramètre flags.

GV* gv_fetchmeth_autoload(stockage HV*,
nom du caractère const*,
lentille STRLEN, niveau I32)

gv_fetchmeth_pv
Exactement comme "gv_fetchmeth_pvn", mais prend une chaîne terminée par zéro au lieu d'un
paire chaîne/longueur.

GV* gv_fetchmeth_pv(HV* stash, const char* nom,
niveau I32, drapeaux U32)

gv_fetchmeth_pvn
Renvoie le glob avec le "nom" donné et un sous-programme défini ou "NULL". le
glob vit dans la "cache" donnée, ou dans les cachettes accessibles via @ISA et
UNIVERSEL::.

L'argument "level" doit être 0 ou -1. Si "level==0", comme effet secondaire
crée un glob avec le "nom" donné dans la "cachette" donnée qui, dans le cas de
success contient un alias pour le sous-programme et configure les informations de mise en cache pour cela
mondial.

Les seules valeurs significatives pour les "drapeaux" sont GV_SUPER et SVf_UTF8.

GV_SUPER indique que l'on veut rechercher la méthode dans les superclasses du
"planque".

Le GV renvoyé par "gv_fetchmeth" peut être une entrée de cache de méthode, qui n'est pas
visible pour le code Perl. Ainsi, lorsque vous appelez "call_sv", vous ne devez pas utiliser le GV
directement; à la place, vous devez utiliser le CV de la méthode, qui peut être obtenu auprès du
GV avec la macro "GvCV".

GV* gv_fetchmeth_pvn(HV* stash, const char* nom,
Objectif STRLEN, niveau I32,
drapeaux U32)

gv_fetchmeth_pvn_autoload
Pareil que gv_fetchmeth_pvn(), mais recherche également les sous-routines chargées automatiquement. Renvoie un
glob pour le sous-programme.

Pour un sous-programme chargé automatiquement sans GV, créera un GV même si "niveau < 0".
Pour un sous-programme chargé automatiquement sans stub, GvCV() du résultat peut être nul.

Actuellement, la seule valeur significative pour les « drapeaux » est SVf_UTF8.

GV* gv_fetchmeth_pvn_autoload(stockage HV*,
nom du caractère const*,
Objectif STRLEN, niveau I32,
drapeaux U32)

gv_fetchmeth_pv_autoload
Exactement comme "gv_fetchmeth_pvn_autoload", mais prend une chaîne à zéro terminal
au lieu d'une paire chaîne/longueur.

GV* gv_fetchmeth_pv_autoload(stockage HV*,
nom du caractère const*,
niveau I32, drapeaux U32)

gv_fetchmeth_sv
Exactement comme "gv_fetchmeth_pvn", mais prend la chaîne de nom sous la forme d'un SV
au lieu d'une paire chaîne/longueur.

GV* gv_fetchmeth_sv(HV* réserve, SV* nomsv,
niveau I32, drapeaux U32)

gv_fetchmeth_sv_autoload
Exactement comme "gv_fetchmeth_pvn_autoload", mais prend la chaîne de nom sous la forme de
un SV au lieu d'une paire chaîne/longueur.

GV* gv_fetchmeth_sv_autoload(HV* réserve, SV* nomsv,
niveau I32, drapeaux U32)

gv_init L'ancienne forme de gv_init_pvn(). Il ne fonctionne pas avec les chaînes UTF8, car il n'a pas
paramètre de drapeaux. Si le paramètre "multi" est défini, le drapeau GV_ADDMULTI sera
transmis à gv_init_pvn().

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

gv_init_pv
Pareil que gv_init_pvn(), mais prend une chaîne terminée par zéro pour le nom au lieu de
paramètres char * et longueur séparés.

void gv_init_pv(GV* gv, HV* stash, const char* nom,
drapeaux U32)

gv_init_pvn
Convertit un scalaire en typeglob. C'est un typeglob incoercible ; attribuer un
référence à celui-ci affectera à l'un de ses emplacements, au lieu de l'écraser en tant que
arrive avec les typeglobs créés par SvSetSV. Conversion de tout scalaire qui est SvOK()
peut produire des résultats imprévisibles et est réservé à l'usage interne de perl.

"gv" est le scalaire à convertir.

"stash" est la cachette/paquet parent, le cas échéant.

"name" et "len" donnent le nom. Le nom ne doit pas être qualifié ; c'est-à-dire qu'il doit
ne pas inclure le nom du package. Si "gv" est un élément caché, c'est celui de l'appelant
responsabilité de s'assurer que le nom passé à cette fonction correspond au nom de
l'élément. Si cela ne correspond pas, la comptabilité interne de perl sortira de
synchroniser.

"flags" peut être défini sur SVf_UTF8 si "name" est une chaîne UTF8, ou la valeur de retour de
SvUTF8(sv). Il peut également prendre le drapeau GV_ADDMULTI, ce qui signifie prétendre que
le GV a déjà été vu (c'est-à-dire supprimer les avertissements "Utilisé une fois").

void gv_init_pvn(GV* gv, HV* stash, const char* nom,
lentille STRLEN, drapeaux U32)

gv_init_sv
Pareil que gv_init_pvn(), mais prend un SV * pour le nom au lieu d'un caractère séparé *
et les paramètres de longueur. « drapeaux » est actuellement inutilisé.

void gv_init_sv(GV* gv, HV* cachette, SV* nomsv,
drapeaux U32)

gv_stashv
Renvoie un pointeur vers la cachette d'un package spécifié. Utilise "strlen" pour
détermine la longueur de "name", puis appelle "gv_stashpvn()".

HV* gv_stashpv(const char* nom, indicateurs I32)

gv_stashpvn
Renvoie un pointeur vers la cachette d'un package spécifié. Le paramètre "namelen"
indique la longueur du "nom", en octets. "drapeaux" est passé à
"gv_fetchpvn_flags()", donc s'il est défini sur "GV_ADD", le package sera créé si
il n'existe pas déjà. Si le package n'existe pas et que "flags" vaut 0 (ou tout autre
autre paramètre qui ne crée pas de packages), alors NULL est renvoyé.

Les drapeaux peuvent être l'un des suivants :

GV_ADD
SVf_UTF8
GV_NOADD_NOINIT
GV_NOINIT
GV_NOEXPAND
GV_ADDMG

Les plus importants sont probablement GV_ADD et SVf_UTF8.

Remarque, l'utilisation de "gv_stashsv" au lieu de "gv_stashpvn" dans la mesure du possible est fortement
recommandé pour des raisons de performances.

HV* gv_stashpvn(const char* nom, U32 namelen,
drapeaux I32)

gv_stashvs
Comme "gv_stashpvn", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

HV* gv_stashpvs(const char* nom, I32 créer)

gv_stashsv
Renvoie un pointeur vers la cachette d'un package spécifié. Voir "gv_stashpvn".

Notez que cette interface est fortement préférée à "gv_stashpvn" pour les performances
les raisons.

HV* gv_stashsv(SV* sv, indicateurs I32)

définir
Définit PL_defoutgv, le descripteur de fichier par défaut pour la sortie, sur le typeglob transmis.
Comme PL_defoutgv "possède" une référence sur son typeglob, le nombre de références du
passé dans typeglob est augmenté de un, et le nombre de références du typeglob
vers lequel PL_defoutgv pointe est diminué de un.

annuler setdefout(GV* gv)

Pratique Nos valeurs

Pointeur Nullav Null AV.

(obsolète - utilisez "(AV *)NULL" à la place)

Nullch Pointeur de caractère nul. (N'est plus disponible lorsque "PERL_CORE" est défini.)

Nullcv Pointeur de CV nul.

(obsolète - utilisez "(CV *)NULL" à la place)

Pointeur Null HV.

(obsolète - utilisez "(HV *)NULL" à la place)

Nullsv Pointeur SV nul. (N'est plus disponible lorsque "PERL_CORE" est défini.)

Hash Manipulation Les fonctions

Une structure HV représente un hachage Perl. Il se compose principalement d'un tableau de pointeurs, chacun
qui pointe vers une liste chaînée de structures HE. Le tableau est indexé par le hachage
fonction de la clé, de sorte que chaque liste chaînée représente toutes les entrées de hachage avec le même
valeur de hachage. Chaque HE contient un pointeur vers la valeur réelle, plus un pointeur vers un HEK
structure qui contient la clé et la valeur de hachage.

cop_fetch_label
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Renvoie l'étiquette attachée à un flic. Le pointeur de drapeaux peut être défini sur "SVf_UTF8"
ou 0.

const char * cop_fetch_label(COP *const flic,
STRLEN *len, U32 *drapeaux)

cop_store_label
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Enregistrez une étiquette dans un "cop_hints_hash". Vous devez définir les indicateurs sur "SVf_UTF8" pour un
étiquette utf-8.

void cop_store_label(COP *const flic,
const char *étiquette, STRLEN len,
drapeaux U32)

get_hv Renvoie le HV du hachage Perl spécifié. Les "drapeaux" sont passés à "gv_fetchpv".
Si "GV_ADD" est défini et que la variable Perl n'existe pas, elle sera créée.
Si « drapeaux » est égal à zéro et que la variable n'existe pas, NULL est renvoyé.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

HV* get_hv(const char *nom, indicateurs I32)

HEf_SVKEY
Ce drapeau, utilisé dans le slot de longueur des entrées de hachage et des structures magiques, spécifie
la structure contient un pointeur "SV*" où un pointeur "char*" est attendu.
(Pour information seulement - à ne pas utiliser).

HeHASH Renvoie le hachage calculé stocké dans l'entrée de hachage.

U32 HeHASH(IL* il)

HeKEY Renvoie le pointeur réel stocké dans l'emplacement de clé de l'entrée de hachage. Le pointeur
peut être "char*" ou "SV*", selon la valeur de "HeKLEN()". Peut être
assigné à. Les macros "HePV()" ou "HeSVKEY()" sont généralement préférables pour
trouver la valeur d'une clé.

vide* HeKEY(IL* il)

HeKLEN S'il est négatif et équivaut à "HEf_SVKEY", cela indique que l'entrée contient un
Touche "SV*". Sinon, conserve la longueur réelle de la clé. Peut être affecté à.
La macro "HePV()" est généralement préférable pour trouver des longueurs de clé.

STRLEN HeKLEN (IL* il)

HePV Renvoie l'emplacement de clé de l'entrée de hachage en tant que valeur "char*", en faisant tout ce qui est nécessaire
déréférencement d'éventuelles clés "SV*". La longueur de la chaîne est placée dans "len"
(il s'agit d'une macro, alors faites-le pas utiliser &len). Si vous ne vous souciez pas de la longueur
de la clé est, vous pouvez utiliser la variable globale "PL_na", bien que ce soit un peu moins
efficace que d'utiliser une variable locale. Rappelez-vous cependant que les clés de hachage en perl
sont libres de contenir des valeurs NULL intégrées, donc utiliser "strlen()" ou similaire n'est pas une bonne
moyen de trouver la longueur des clés de hachage. Ceci est très similaire à la macro "SvPV()"
décrit ailleurs dans ce document. Voir aussi "HeUTF8".

Si vous utilisez "HePV" pour obtenir des valeurs à transmettre à "newSVpvn()" pour créer un nouveau SV,
vous devriez envisager d'utiliser "newSVhek(HeKEY_hek(he))" car il est plus efficace.

car* HePV(HE* il, STRLEN len)

HeSVKEY Renvoie la clé sous la forme d'un « SV* » ou « NULL » si l'entrée de hachage ne contient pas de « SV* »
clé.

SV* HeSVKEY(IL* il)

IlSVKEY_force
Renvoie la clé sous forme de "SV*". Créera et renverra un mortel temporaire "SV*" si
l'entrée de hachage contient uniquement une clé "char*".

SV* HeSVKEY_force(HE* il)

IlSVKEY_set
Définit la clé sur un "SV*" donné, en prenant soin de définir les indicateurs appropriés sur
indique la présence d'une touche "SV*", et renvoie le même "SV*".

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

HeUTF8 Renvoie si la valeur "char *" renvoyée par "HePV" est encodée en UTF-8, en faisant
tout déréférencement nécessaire d'éventuelles clés "SV*". La valeur renvoyée sera 0
ou non-0, pas nécessairement 1 (ou même une valeur avec des bits bas définis), donc do pas
attribuez-le aveuglément à une variable "bool", car "bool" peut être un typedef pour "char".

U32 HeUTF8(HE* il)

HeVAL Renvoie l'emplacement de valeur (type "SV*") stocké dans l'entrée de hachage. Peut être affecté à.

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

SV* HeVAL(HE* il)

HvENAME Renvoie le nom effectif d'une cache, ou NULL s'il n'y en a pas. L'efficace
name représente un emplacement dans la table des symboles où réside cette cachette. Il est
mis à jour automatiquement lorsque les packages sont aliasés ou supprimés. Une cachette qui n'est pas
plus dans la table des mnémoniques n'a pas de nom effectif. Ce nom est préférable à
"HvNAME" à utiliser dans les linéarisations MRO et les caches isa.

char* HvENAME(HV* cachette)

HvÉMAILLEN
Renvoie la longueur du nom effectif de la cache.

STRLEN HvENAMELEN (HV * cachette)

HvENAMEUTF8
Renvoie true si le nom effectif est en codage UTF8.

caractère non signé HvENAMEUTF8(HV *stash)

HvNAME Renvoie le nom de package d'une cachette, ou NULL si "stash" n'est pas une cachette. Voir
"SvSTASH", "CvSTASH".

char* HvNAME(HV* cachette)

HvNAMELEN
Renvoie la longueur du nom de la cache.

STRLEN HvNAMELEN (HV * cachette)

HvNOMUTF8
Renvoie true si le nom est en codage UTF8.

caractère non signé HvNAMEUTF8(HV *stash)

hv_assert
Vérifiez qu'un hachage est dans un état de cohérence interne.

annuler hv_assert(HV *hv)

hv_clear
Libère tous les éléments d'un hachage, le laissant vide. L'équivalent XS de
"% hachage = ()". Voir aussi "hv_undef".

Voir "av_clear" pour une note sur le hachage pouvant être invalide au retour.

vide hv_clear(HV *hv)

hv_clear_placeholders
Efface tous les espaces réservés d'un hachage. Si un hachage restreint a l'une de ses clés
marqué comme en lecture seule et que la clé est ensuite supprimée, la clé n'est pas réellement
supprimé mais est marqué en lui attribuant une valeur de &PL_sv_placeholder. Cela le marque
il sera donc ignoré par les opérations futures telles que l'itération sur le hachage, mais
permettra toujours au hachage d'avoir une valeur réaffectée à la clé dans le futur
point. Cette fonction efface toutes ces clés d'espace réservé du hachage. Voir
Hachage ::Util ::lock_keys() pour un exemple de son utilisation.

annuler hv_clear_placeholders(HV *hv)

hv_copy_hints_hv
Une version spécialisée de "newHVhv" pour copier "%^H". oh doit être un pointeur vers un
hachage (qui peut avoir la magie "%^H", mais devrait être généralement non magique), ou "NULL"
(interprété comme un hachage vide). Le contenu de oh est copié dans un nouveau hachage, qui
a la magie spécifique "%^H" ajoutée. Un pointeur vers le nouveau hachage est renvoyé.

HV * hv_copy_hints_hv (HV * ohv)

hv_delete
Supprime une paire clé/valeur dans le hachage. Le SV de la valeur est supprimé du hachage,
rendu mortel, et retourné à l'appelant. La valeur absolue de "klen" est la
longueur de la clé. Si "klen" est négatif, la clé est supposée être dans
Unicode codé en UTF-8. La valeur « drapeaux » sera normalement zéro ; si réglé sur
G_DISCARD puis NULL sera renvoyé. NULL sera également renvoyé si la clé est
introuvable.

SV* hv_delete(HV *hv, caractère const *clé, I32 klen,
drapeaux I32)

hv_delete_ent
Supprime une paire clé/valeur dans le hachage. La valeur SV est supprimée du hachage,
mortel, et est retourné à l'appelant. La valeur « drapeaux » sera normalement zéro ; si
défini sur G_DISCARD alors NULL sera renvoyé. NULL sera également renvoyé si le
la clé n'est pas trouvée. "hash" peut être une valeur de hachage précalculée valide, ou 0 pour demander
il doit être calculé.

SV* hv_delete_ent(HV *hv, SV *keysv, drapeaux I32,
hachage U32)

hv_existe
Renvoie un booléen indiquant si la clé de hachage spécifiée existe. L'absolu
la valeur de "klen" est la longueur de la clé. Si "klen" est négatif, la clé est
supposé être en Unicode codé UTF-8.

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

hv_exists_ent
Renvoie un booléen indiquant si la clé de hachage spécifiée existe. "hachage" peut être
une valeur de hachage précalculée valide, ou 0 pour demander qu'elle soit calculée.

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

hv_fetch
Renvoie le SV qui correspond à la clé spécifiée dans le hachage. L'absolu
la valeur de "klen" est la longueur de la clé. Si "klen" est négatif, la clé est
supposé être en Unicode codé en UTF-8. Si "lval" est défini, l'extraction sera
partie d'un magasin. Cela signifie que s'il n'y a pas de valeur dans le hachage associé à
la clé donnée, puis une est créée et un pointeur vers celle-ci est renvoyé. Le "SV*" il
les points à peuvent être affectés. Mais vérifiez toujours que la valeur de retour est non nulle
avant de le déréférencer à un "SV*".

Voir "Comprendre la magie des hachages et des tableaux liés" dans perlguts pour en savoir plus
informations sur l'utilisation de cette fonction sur les hachages liés.

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

hv_fetchs
Comme "hv_fetch", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

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

hv_fetch_ent
Renvoie l'entrée de hachage qui correspond à la clé spécifiée dans le hachage. "hacher"
doit être un numéro de hachage précalculé valide pour la "clé" donnée, ou 0 si vous voulez que le
fonction pour le calculer. SI "lval" est défini, la récupération fera partie d'un magasin.
Assurez-vous que la valeur de retour n'est pas nulle avant d'y accéder. La valeur de retour lorsque
"hv" est un hachage lié est un pointeur vers un emplacement statique, alors assurez-vous de faire une copie
de la structure si vous avez besoin de la stocker quelque part.

Voir "Comprendre la magie des hachages et des tableaux liés" dans perlguts pour en savoir plus
informations sur l'utilisation de cette fonction sur les hachages liés.

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

hv_fill Renvoie le nombre de compartiments de hachage en cours d'utilisation. Cette fonction est
enveloppé par la macro "HvFILL".

Auparavant, cette valeur était toujours stockée dans la structure HV, ce qui créait un
frais généraux sur chaque hachage (et à peu près chaque objet) pour quelque chose qui était
rarement utilisé. Maintenant, nous le calculons à la demande la première fois qu'il est nécessaire, et
cachez-le si ce calcul va être coûteux à répéter. La valeur mise en cache est
mis à jour par les insertions et les suppressions, mais (actuellement) rejeté si le hachage est
Divisé.

STRLEN hv_fill(HV *const hv)

hv_iterinit
Prépare un point de départ pour parcourir une table de hachage. Renvoie le nombre de clés dans
le hachage (c'est-à-dire le même que "HvUSEDKEYS(hv)"). La valeur de retour est actuellement seulement
significatif pour les hachages sans magie de cravate.

NOTE : Avant la version 5.004_65, "hv_iterinit" renvoyait le nombre de hash
seaux qui se trouvent être en cours d'utilisation. Si vous avez encore besoin de cette valeur ésotérique, vous pouvez
obtenez-le via la macro "HvFILL(hv)".

I32 hv_iterinit(HV *hv)

hv_iterkey
Renvoie la clé à partir de la position actuelle de l'itérateur de hachage. Voir
"hv_iterinit".

char* hv_iterkey(entrée HE*, I32* retlen)

hv_iterkeysv
Renvoie la clé sous forme de "SV*" à partir de la position actuelle de l'itérateur de hachage. le
la valeur de retour sera toujours une copie mortelle de la clé. Voir aussi "hv_iterinit".

SV* hv_iterkeysv(entrée HE*)

hv_iternext
Renvoie les entrées d'un itérateur de hachage. Voir "hv_iterinit".

Vous pouvez appeler "hv_delete" ou "hv_delete_ent" sur l'entrée de hachage que l'itérateur
pointe actuellement, sans perdre votre place ni invalider votre itérateur.
Notez que dans ce cas, l'entrée actuelle est supprimée du hachage avec votre
itérateur contenant la dernière référence à celui-ci. Votre itérateur est signalé pour libérer le
entrée sur le prochain appel à "hv_iternext", donc vous ne devez pas jeter votre itérateur
immédiatement sinon l'entrée fuira - appelez "hv_iternext" pour déclencher la ressource
désallocation.

HE* hv_iternext(HV *hv)

hv_iternextsv
Effectue un "hv_iternext", "hv_iterkey" et "hv_iterval" en une seule opération.

SV* hv_iternextsv(HV *hv, car **key, I32 *retlen)

hv_iternext_flags
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Renvoie les entrées d'un itérateur de hachage. Voir "hv_iterinit" et "hv_iternext". le
la valeur "drapeaux" sera normalement zéro ; si HV_ITERNEXT_WANTPLACEHOLDERS est défini, le
les clés d'espace réservé (pour les hachages restreints) seront retournées en plus de la normale
clés. Par défaut, les espaces réservés sont automatiquement ignorés. Actuellement un
placeholder est implémenté avec une valeur qui est &PL_sv_placeholder. Notez que le
la mise en œuvre des espaces réservés et des hachages restreints peut changer, et le
la mise en œuvre est actuellement insuffisamment abstraite pour que tout changement soit ordonné.

HE* hv_iternext_flags(HV *hv, drapeaux I32)

hv_iterval
Renvoie la valeur à partir de la position actuelle de l'itérateur de hachage. Voir
"hv_iterkey".

SV* hv_iterval(HV *hv, HE *entrée)

hv_magie
Ajoute de la magie à un hachage. Voir "sv_magic".

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

hv_scalaire
Évalue le hachage dans un contexte scalaire et renvoie le résultat. Gère la magie quand
le hachage est lié.

SV* hv_scalaire(HV *hv)

hv_store
Stocke un SV dans un hachage. La clé de hachage est spécifiée comme "clé" et la valeur absolue
de "klen" est la longueur de la clé. Si "klen" est négatif, la clé est supposée être
être en Unicode codé en UTF-8. Le paramètre « hash » est la valeur de hachage précalculée ;
s'il est égal à zéro, Perl le calculera.

La valeur de retour sera NULL si l'opération a échoué ou si la valeur n'avait pas besoin
être réellement stocké dans le hachage (comme dans le cas des hachages liés). Autrement
il peut être déréférencé pour obtenir le "SV*" d'origine. Notez que l'appelant est
responsable d'incrémenter convenablement le compteur de référence de "val" avant le
appel et le décrémenter si la fonction a renvoyé NULL. Effectivement un succès
hv_store prend possession d'une référence à "val". C'est généralement ce que vous
vouloir; un SV nouvellement créé a un nombre de références de un, donc si tout votre code fait est
créer des SV puis les stocker dans un hachage, hv_store possédera la seule référence au
nouveau SV, et votre code n'a pas besoin de faire quoi que ce soit de plus pour le ranger. hv_store est
pas implémenté en tant qu'appel à hv_store_ent, et ne crée pas de SV temporaire pour
la clé, donc si vos données de clé ne sont pas déjà au format SV, utilisez hv_store dans
préférence à hv_store_ent.

Voir "Comprendre la magie des hachages et des tableaux liés" dans perlguts pour en savoir plus
informations sur l'utilisation de cette fonction sur les hachages liés.

SV** hv_store(HV *hv, const char *key, I32 klen,
SV *val, hachage U32)

hv_magasins
Comme "hv_store", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur et
omet le paramètre de hachage.

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

hv_store_ent
Stocke "val" dans un hachage. La clé de hachage est spécifiée comme "clé". Le paramètre "hachage"
est la valeur de hachage précalculée ; s'il est égal à zéro, Perl le calculera. le
la valeur de retour est la nouvelle entrée de hachage ainsi créée. Il sera NULL si l'opération
a échoué ou si la valeur n'avait pas besoin d'être réellement stockée dans le hachage (comme dans
le cas des hachages liés). Sinon, le contenu de la valeur de retour peut être
accédé à l'aide du "He?" macros décrites ici. Notez que l'appelant est
responsable d'incrémenter convenablement le compteur de référence de "val" avant le
appel et le décrémenter si la fonction a renvoyé NULL. Effectivement un succès
hv_store_ent prend possession d'une référence à "val". C'est généralement ce que vous
vouloir; un SV nouvellement créé a un nombre de références de un, donc si tout votre code fait est
créer des SV puis les stocker dans un hachage, hv_store possédera la seule référence au
nouveau SV, et votre code n'a pas besoin de faire quoi que ce soit de plus pour le ranger. Noter que
hv_store_ent ne lit que la "clé" ; contrairement à "val" il ne s'en approprie pas,
donc maintenir le bon nombre de références sur la « clé » est entièrement l'affaire de l'appelant
responsabilité. hv_store n'est pas implémenté en tant qu'appel à hv_store_ent, et ne
ne pas créer de SV temporaire pour la clé, donc si vos données de clé ne sont pas déjà dans SV
form puis utilisez hv_store de préférence à hv_store_ent.

Voir "Comprendre la magie des hachages et des tableaux liés" dans perlguts pour en savoir plus
informations sur l'utilisation de cette fonction sur les hachages liés.

HE* hv_store_ent(HV *hv, SV *key, SV *val, hachage U32)

hv_undef
Indéfinit le hachage. L'équivalent XS de "undef(%hash)".

En plus de libérer tous les éléments du hachage (comme hv_clear()), cela libère également
toutes les données auxiliaires et le stockage associé au hachage.

Voir "av_clear" pour une note sur le hachage pouvant être invalide au retour.

vide hv_undef(HV *hv)

newHV Crée un nouveau HV. Le compteur de référence est défini sur 1.

HV* nouveauHV()

Crochet manipulation

Ces fonctions fournissent des moyens pratiques et sûrs pour les threads de manipuler les variables de hook.

wrap_op_checker
Insère une fonction C dans la chaîne de fonctions de contrôle pour un type d'opération spécifié. Cette
est le moyen préféré pour manipuler le tableau "PL_check". code opération précise quel
le type d'opération doit être affecté. nouveau_vérificateur est un pointeur vers la fonction C qui est
à ajouter à la chaîne de contrôle de cet opcode, et vieux_checker_p indique le stockage
emplacement où un pointeur vers la fonction suivante dans la chaîne sera stocké. le
valeur de nouveau_pointeur est écrite dans le tableau "PL_check", tandis que la valeur
précédemment stocké là est écrit sur *old_checker_p.

La fonction doit être définie comme ceci :

OP statique *new_checker(pTHX_OP *op) { ... }

Il est destiné à être appelé de cette manière:

new_checker(aTHX_op)

vieux_checker_p devrait être défini comme ceci :

statique Perl_check_t old_checker_p;

"PL_check" est global à l'ensemble d'un processus, et à un module souhaitant s'accrocher
la vérification peut se trouver invoquée plus d'une fois par processus, généralement dans
fils différents. Pour gérer cette situation, cette fonction est idempotente. le
Localisation *old_checker_p doit initialement (une fois par processus) contenir un pointeur nul.
Variable AC de durée statique (déclarée au niveau du fichier, généralement également marquée
"static" pour lui donner un lien interne) sera implicitement initialisé
de manière appropriée, s'il n'a pas d'initialiseur explicite. Cette fonction va
ne modifie réellement la chaîne de contrôle que s'il trouve *old_checker_p être nul. Cette
La fonction est également thread-safe à petite échelle. Il utilise un verrouillage approprié pour
éviter les conditions de concurrence en accédant à "PL_check".

Lorsque cette fonction est appelée, la fonction référencée par nouveau_vérificateur doit être prêt
être appelé, sauf pour *old_checker_p étant non rempli. Dans une situation de filetage,
nouveau_vérificateur peut être appelée immédiatement, même avant que cette fonction ne soit retournée.
*old_checker_p sera toujours correctement réglé avant nouveau_vérificateur est appelé. Si
nouveau_vérificateur décide de ne rien faire de spécial avec une opération qui lui est donnée (qui
est le cas habituel pour la plupart des utilisations de l'accrochage de contrôle d'opération), il doit enchaîner le contrôle
fonction référencée par *old_checker_p.

Si vous souhaitez influencer la compilation des appels vers un sous-programme spécifique, utilisez
"cv_set_call_checker" plutôt que d'accrocher la vérification de toutes les opérations "entersub".

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

Lexer interface

C'est la couche inférieure de l'analyseur Perl, gérant les caractères et les jetons.

lex_bufutf8
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Indique si les octets du tampon lexer ("PL_parser->linestr") doivent être
interprété comme l'encodage UTF-8 des caractères Unicode. Sinon, ils devraient être
interprétés comme des caractères Latin-1. Ceci est analogue au drapeau "SvUTF8" pour
scalaires.

En mode UTF-8, il n'est pas garanti que le tampon lexer contienne réellement
UTF-8. Le code Lexing doit être robuste face à un encodage invalide.

Le drapeau "SvUTF8" réel du scalaire "PL_parser->linestr" est significatif, mais
pas toute l'histoire concernant l'encodage des caractères d'entrée. Normalement, lorsqu'un fichier
est en cours de lecture, le scalaire contient des octets et son indicateur "SvUTF8" est éteint, mais le
Les octets doivent être interprétés comme UTF-8 si le pragma "use utf8" est en vigueur.
Pendant une évaluation de chaîne, cependant, le scalaire peut avoir le drapeau "SvUTF8" activé, et dans
dans ce cas, ses octets doivent être interprétés comme UTF-8 à moins que le pragma "use bytes"
est en vigueur. Cette logique peut changer à l'avenir ; utiliser cette fonction au lieu de
mettre en œuvre la logique vous-même.

booléen lex_bufutf8()

lex_discard_to
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Supprime la première partie du tampon "PL_parser->linestr", jusqu'à ptrL’
le contenu restant du tampon sera déplacé et tous les pointeurs dans le tampon
mis à jour de manière appropriée. ptr ne doit pas être plus tard dans le tampon que la position de
"PL_parser->bufptr" : il n'est pas permis de supprimer du texte qui n'a pas encore été lexé.

Normalement, il ne s'agit pas nécessairement de le faire directement, car il suffit d'utiliser le
comportement d'élimination implicite de "lex_next_chunk" et des éléments basés sur celui-ci.
Cependant, si un jeton s'étend sur plusieurs lignes et que le code de lexing a conservé
plusieurs lignes de texte dans le tampon à cet effet, puis après l'achèvement de
le jeton, il serait sage de supprimer explicitement les lignes précédentes désormais inutiles,
pour éviter que les futurs jetons multi-lignes augmentent le tampon sans limite.

annuler lex_discard_to(char *ptr)

lex_grow_linestr
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Réalloue le tampon lexer ("PL_parser->linestr") pour accueillir au moins len
octets (y compris la terminaison "NUL"). Renvoie un pointeur vers le réalloué
amortir. Ceci est nécessaire avant toute modification directe du buffer
cela augmenterait sa longueur. "lex_stuff_pvn" fournit un moyen plus pratique de
insérer du texte dans le tampon.

N'utilisez pas "SvGROW" ou "sv_grow" directement sur "PL_parser->linestr" ; cette fonction
met à jour toutes les variables du lexer qui pointent directement dans le tampon.

char * lex_grow_linestr(STRLEN longueur)

lex_next_chunk
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Lit le prochain morceau de texte à lexer, en l'ajoutant à "PL_parser->linestr".
Cela devrait être appelé lorsque le code lexing a regardé à la fin du morceau actuel
et veut en savoir plus. Il est habituel, mais pas nécessaire, pour lexing d'avoir
consommé la totalité du morceau actuel à ce moment.

Si "PL_parser->bufptr" pointe vers la toute fin du morceau actuel (c'est-à-dire, le
morceau actuel a été entièrement consommé), normalement le morceau actuel sera
rejeté en même temps que le nouveau morceau est lu. Si drapeaux inclut
"LEX_KEEP_PREVIOUS", le morceau actuel ne sera pas supprimé. Si le courant
morceau n'a pas été entièrement consommé, alors il ne sera pas jeté indépendamment de
le drapeau.

Renvoie vrai si un nouveau texte a été ajouté au tampon, ou faux si le tampon a
atteint la fin du texte saisi.

bool lex_next_chunk (indicateurs U32)

lex_peek_unichar
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Anticipe un caractère (Unicode) dans le texte en cours de lexique. Retour
le point de code (valeur entière non signée) du caractère suivant, ou -1 si lexing a
atteint la fin du texte saisi. Pour consommer le caractère aperçu, utilisez
"lex_read_unichar".

Si le caractère suivant est dans (ou s'étend dans) le prochain morceau de texte d'entrée, le
le morceau suivant sera lu. Normalement, le morceau actuel sera rejeté au
même temps, mais si drapeaux inclut "LEX_KEEP_PREVIOUS" alors le morceau actuel sera
pas être jeté.

Si l'entrée est interprétée comme UTF-8 et qu'une erreur d'encodage UTF-8 est
rencontré, une exception est générée.

I32 lex_peek_unichar (indicateurs U32)

lex_read_space
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Lit les espaces facultatifs, dans le style Perl, dans le texte en cours de lexique. le
les espaces peuvent inclure des caractères blancs ordinaires et des commentaires de style Perl.
Les directives "#line" sont traitées si elles sont rencontrées. "PL_parser->bufptr" est déplacé
passé les espaces, de sorte qu'il pointe vers un caractère non espace (ou la fin du
Texte de saisie).

Si les espaces s'étendent dans le prochain morceau de texte d'entrée, le prochain morceau sera lu
in. Normalement, le morceau actuel sera supprimé en même temps, mais si drapeaux
inclut "LEX_KEEP_PREVIOUS" alors le morceau actuel ne sera pas supprimé.

void lex_read_space (indicateurs U32)

lex_read_to
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Consommer du texte dans le tampon lexer, de "PL_parser->bufptr" jusqu'à ptr
avance "PL_parser->bufptr" pour correspondre ptr, en effectuant la comptabilité correcte
chaque fois qu'un caractère de nouvelle ligne est passé. C'est la façon normale de consommer lexed
texte.

L'interprétation des octets du tampon peut être extraite en utilisant le légèrement
fonctions de niveau supérieur "lex_peek_unichar" et "lex_read_unichar".

annuler lex_read_to(char *ptr)

lex_read_unichar
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Lit le caractère (Unicode) suivant dans le texte en cours de lexique. Renvoie le
point de code (valeur entière non signée) du caractère lu, et se déplace
"PL_parser->bufptr" après le caractère, ou renvoie -1 si lexing a atteint le
fin du texte saisi. Pour examiner de manière non destructive le caractère suivant, utilisez
"lex_peek_unichar" à la place.

Si le caractère suivant est dans (ou s'étend dans) le prochain morceau de texte d'entrée, le
le morceau suivant sera lu. Normalement, le morceau actuel sera rejeté au
même temps, mais si drapeaux inclut "LEX_KEEP_PREVIOUS" alors le morceau actuel sera
pas être jeté.

Si l'entrée est interprétée comme UTF-8 et qu'une erreur d'encodage UTF-8 est
rencontré, une exception est générée.

I32 lex_read_unichar (indicateurs U32)

lex_start
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Crée et initialise un nouvel objet d'état lexer/parser, fournissant un contexte dans
à analyser et analyser à partir d'une nouvelle source de code Perl. Un pointeur vers le nouvel état
l'objet est placé dans "PL_parser". Une entrée est faite sur la pile de sauvegarde de sorte qu'au moment
le déroulement du nouvel objet d'état sera détruit et l'ancienne valeur de
"PL_parser" sera restauré. Rien d'autre n'a besoin d'être fait pour nettoyer l'analyse
contexte

Le code à analyser provient de en ligne et RSFP. en ligne, si non nul, fournit un
chaîne (sous forme SV) contenant le code à analyser. Une copie de la chaîne est faite,
donc modification ultérieure de en ligne n'affecte pas l'analyse. RSFP, si non nul,
fournit un flux d'entrée à partir duquel le code sera lu pour être analysé. Si les deux sont
non nul, le code dans en ligne vient en premier et doit consister en des lignes complètes de
entrée, et RSFP fournit le reste de la source.

Le manuel de formation drapeaux paramètre est réservé pour une utilisation future. Actuellement, il n'est utilisé que par perl
en interne, donc les extensions doivent toujours passer zéro.

void lex_start(SV *ligne, PerlIO *rsfp, drapeaux U32)

lex_truc_pv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Insérez des caractères dans le tampon lexer ("PL_parser->linestr"), immédiatement après
le point de lexage courant ("PL_parser->bufptr"), en réallouant le tampon si
nécessaire. Cela signifie que le code de lexage qui s'exécute plus tard verra les caractères comme
s'ils étaient apparus dans l'entrée. Il n'est pas recommandé de le faire dans le cadre de
l'analyse normale, et la plupart des utilisations de cette fonction courent le risque d'insérer
les caractères sont interprétés de manière non intentionnelle.

La chaîne à insérer est représentée par des octets commençant à pv et continue
au premier nul. Ces octets sont interprétés comme UTF-8 ou Latin-1,
selon que le drapeau "LEX_STUFF_UTF8" est défini dans drapeaux. Les personnages
sont recodés pour le tampon lexer, selon la façon dont le tampon est actuellement
interprété ("lex_bufutf8"). S'il n'est pas pratique de terminer une chaîne à zéro
être inséré, la fonction "lex_stuff_pvn" est plus appropriée.

void lex_stuff_pv(const char *pv, drapeaux U32)

lex_truc_pvn
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Insérez des caractères dans le tampon lexer ("PL_parser->linestr"), immédiatement après
le point de lexage courant ("PL_parser->bufptr"), en réallouant le tampon si
nécessaire. Cela signifie que le code de lexage qui s'exécute plus tard verra les caractères comme
s'ils étaient apparus dans l'entrée. Il n'est pas recommandé de le faire dans le cadre de
l'analyse normale, et la plupart des utilisations de cette fonction courent le risque d'insérer
les caractères sont interprétés de manière non intentionnelle.

La chaîne à insérer est représentée par len octets commençant à pv. Ces
octets sont interprétés comme UTF-8 ou Latin-1, selon que le
L'indicateur "LEX_STUFF_UTF8" est défini dans drapeaux. Les caractères sont recodés pour le lexer
buffer, selon la façon dont le buffer est actuellement interprété
("lex_bufutf8"). Si une chaîne à insérer est disponible sous forme de scalaire Perl, le
La fonction "lex_stuff_sv" est plus pratique.

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

lex_truc_pvs
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Comme "lex_stuff_pvn", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

void lex_stuff_pvs(const char *pv, drapeaux U32)

lex_truc_sv
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Insérez des caractères dans le tampon lexer ("PL_parser->linestr"), immédiatement après
le point de lexage courant ("PL_parser->bufptr"), en réallouant le tampon si
nécessaire. Cela signifie que le code de lexage qui s'exécute plus tard verra les caractères comme
s'ils étaient apparus dans l'entrée. Il n'est pas recommandé de le faire dans le cadre de
l'analyse normale, et la plupart des utilisations de cette fonction courent le risque d'insérer
les caractères sont interprétés de manière non intentionnelle.

La chaîne à insérer est la valeur de chaîne de sv. Les caractères sont recodés
pour le tampon lexer, selon la façon dont le tampon est actuellement interprété
("lex_bufutf8"). Si une chaîne à insérer n'est pas déjà un scalaire Perl, le
La fonction "lex_stuff_pvn" évite d'avoir à construire un scalaire.

void lex_stuff_sv (SV * sv, drapeaux U32)

lex_unstuff
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Ignore le texte sur le point d'être lexé, de "PL_parser->bufptr" jusqu'à ptr. Texte
Abonnement ptr sera déplacé et le tampon raccourci. Cela cache les rejets
texte de n'importe quel code lexing qui s'exécute plus tard, comme si le texte n'était jamais apparu.

Ce n'est pas la façon normale de consommer du texte lexé. Pour cela, utilisez "lex_read_to".

void lex_unstuff(char *ptr)

parse_arithexpr
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analyser une expression arithmétique Perl. Cela peut contenir des opérateurs de priorité vers le bas
aux opérateurs de décalage de bits. L'expression doit être suivie (et donc terminée)
soit par un opérateur de comparaison ou de priorité inférieure, soit par quelque chose qui
terminent normalement une expression telle que le point-virgule. Si drapeaux inclut
"PARSE_OPTIONAL" alors l'expression est facultative, sinon elle est obligatoire. Ce
c'est à l'appelant de s'assurer que l'état de l'analyseur dynamique ("PL_parser" et al) est
correctement défini pour refléter la source du code à analyser et le lexique
contexte de l'expression.

L'arborescence des opérations représentant l'expression est renvoyée. Si une expression facultative est
absent, un pointeur nul est renvoyé, sinon le pointeur sera non nul.

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, un arbre d'opérations valide est
retourné quand même. L'erreur est reflétée dans l'état de l'analyseur, résultant normalement
dans une seule exception au plus haut niveau d'analyse qui couvre toute la compilation
erreurs qui se sont produites. Certaines erreurs de compilation, cependant, lèveront une exception
immédiatement.

OP * parse_arithexpr (indicateurs U32)

parse_barestmt
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analysez une seule instruction Perl sans fioritures. Cela peut être un impératif normal
déclaration ou une déclaration qui a un effet au moment de la compilation. Il n'inclut aucun
étiquette ou autre accessoire. Il appartient à l'appelant de s'assurer que la dynamique
l'état de l'analyseur ("PL_parser" et al) est correctement défini pour refléter la source du
le code à analyser et le contexte lexical de l'instruction.

L'arborescence des opérations représentant l'instruction est renvoyée. Cela peut être un pointeur nul si
l'instruction est nulle, par exemple s'il s'agissait en fait d'une définition de sous-programme
(qui a des effets secondaires au moment de la compilation). Si non nul, ce sera ops directement
implémentant l'instruction, appropriée pour passer à "newSTATEOP". Ça ne sera pas
incluent normalement un "état suivant" ou une opération équivalente (à l'exception de ceux intégrés dans un
portée entièrement contenue dans la déclaration).

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, une arborescence d'opérations valide (la plupart
probablement null) est renvoyé de toute façon. L'erreur est reflétée dans l'état de l'analyseur,
résultant normalement en une seule exception au niveau supérieur de l'analyse qui couvre
toutes les erreurs de compilation qui se sont produites. Certaines erreurs de compilation, cependant,
lancer une exception immédiatement.

Le manuel de formation drapeaux Le paramètre est réservé pour une utilisation future et doit toujours être égal à zéro.

OP * parse_barestmt (drapeaux U32)

analyser_block
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analyser un seul bloc de code Perl complet. Il s'agit d'un corset d'ouverture, d'un
séquence d'instructions et une accolade fermante. Le bloc constitue un lexical
portée, de sorte que "mes" variables et divers effets de compilation peuvent être contenus dans
ce. Il appartient à l'appelant de s'assurer que l'état de l'analyseur dynamique ("PL_parser"
et al) est correctement défini pour refléter la source du code à analyser et le
contexte lexical de l'énoncé.

L'arborescence des opérations représentant le bloc de code est renvoyée. C'est toujours une vraie opération,
jamais un pointeur nul. Ce sera normalement une liste "lineseq", y compris "nextstate"
ou opérations équivalentes. Aucune opération pour construire n'importe quel type de portée d'exécution n'est incluse par
en raison du fait qu'il s'agit d'un bloc.

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, une arborescence d'opérations valide (la plupart
probablement null) est renvoyé de toute façon. L'erreur est reflétée dans l'état de l'analyseur,
résultant normalement en une seule exception au niveau supérieur de l'analyse qui couvre
toutes les erreurs de compilation qui se sont produites. Certaines erreurs de compilation, cependant,
lancer une exception immédiatement.

Le manuel de formation drapeaux Le paramètre est réservé pour une utilisation future et doit toujours être égal à zéro.

OP * parse_block (drapeaux U32)

parse_fullexpr
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analyser une seule expression Perl complète. Cela permet l'expression complète de la grammaire,
y compris les opérateurs de priorité la plus basse tels que « ou ». L'expression doit être
suivi (et donc terminé) par un signe qu'une expression serait normalement
terminé par : la fin du fichier, la ponctuation entre crochets fermants, le point-virgule ou l'un des
les mots-clés qui signalent un modificateur d'instruction d'expression postfix. Si drapeaux
inclut "PARSE_OPTIONAL" alors l'expression est facultative, sinon elle est
obligatoire. Il appartient à l'appelant de s'assurer que l'état de l'analyseur dynamique
("PL_parser" et al) est correctement défini pour refléter la source du code à être
analysé et le contexte lexical de l'expression.

L'arborescence des opérations représentant l'expression est renvoyée. Si une expression facultative est
absent, un pointeur nul est renvoyé, sinon le pointeur sera non nul.

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, un arbre d'opérations valide est
retourné quand même. L'erreur est reflétée dans l'état de l'analyseur, résultant normalement
dans une seule exception au plus haut niveau d'analyse qui couvre toute la compilation
erreurs qui se sont produites. Certaines erreurs de compilation, cependant, lèveront une exception
immédiatement.

OP * parse_fullexpr (indicateurs U32)

parse_fullstmt
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analyser une seule instruction Perl complète. Cela peut être un énoncé impératif normal
ou une déclaration qui a un effet au moment de la compilation et peut inclure des étiquettes facultatives.
Il appartient à l'appelant de s'assurer que l'état de l'analyseur dynamique ("PL_parser" et al)
est correctement défini pour refléter la source du code à analyser et le lexique
contexte de la déclaration.

L'arborescence des opérations représentant l'instruction est renvoyée. Cela peut être un pointeur nul si
l'instruction est nulle, par exemple s'il s'agissait en fait d'une définition de sous-programme
(qui a des effets secondaires au moment de la compilation). S'il n'est pas nul, il sera le résultat d'un
appel "newSTATEOP", comprenant normalement un "nextstate" ou une opération équivalente.

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, une arborescence d'opérations valide (la plupart
probablement null) est renvoyé de toute façon. L'erreur est reflétée dans l'état de l'analyseur,
résultant normalement en une seule exception au niveau supérieur de l'analyse qui couvre
toutes les erreurs de compilation qui se sont produites. Certaines erreurs de compilation, cependant,
lancer une exception immédiatement.

Le manuel de formation drapeaux Le paramètre est réservé pour une utilisation future et doit toujours être égal à zéro.

OP * parse_fullstmt (drapeaux U32)

analyse_étiquette
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analyser une seule étiquette, éventuellement facultative, du type qui peut préfixer un Perl
déclaration. Il appartient à l'appelant de s'assurer que l'état de l'analyseur dynamique
("PL_parser" et al) est correctement défini pour refléter la source du code à être
analysé. Si drapeaux inclut "PARSE_OPTIONAL" alors l'étiquette est facultative, sinon
c'est obligatoire.

Le nom de l'étiquette est renvoyé sous la forme d'un nouveau scalaire. Si une option
label est absent, un pointeur nul est renvoyé.

Si une erreur se produit lors de l'analyse, ce qui ne peut se produire que si l'étiquette est obligatoire, un
une étiquette valide est renvoyée de toute façon. L'erreur est reflétée dans l'état de l'analyseur,
résultant normalement en une seule exception au niveau supérieur de l'analyse qui couvre
toutes les erreurs de compilation qui se sont produites.

SV * parse_label (indicateurs U32)

parse_listexpr
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analyser une expression de liste Perl. Cela peut contenir des opérateurs de préséance jusqu'à
l'opérateur virgule. L'expression doit être suivie (et donc terminée) soit
par un opérateur logique de faible priorité tel que "ou" ou par quelque chose qui
terminent normalement une expression telle que le point-virgule. Si drapeaux inclut
"PARSE_OPTIONAL" alors l'expression est facultative, sinon elle est obligatoire. Ce
c'est à l'appelant de s'assurer que l'état de l'analyseur dynamique ("PL_parser" et al) est
correctement défini pour refléter la source du code à analyser et le lexique
contexte de l'expression.

L'arborescence des opérations représentant l'expression est renvoyée. Si une expression facultative est
absent, un pointeur nul est renvoyé, sinon le pointeur sera non nul.

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, un arbre d'opérations valide est
retourné quand même. L'erreur est reflétée dans l'état de l'analyseur, résultant normalement
dans une seule exception au plus haut niveau d'analyse qui couvre toute la compilation
erreurs qui se sont produites. Certaines erreurs de compilation, cependant, lèveront une exception
immédiatement.

OP * parse_listexpr (indicateurs U32)

parse_stmtseq
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analyse une séquence de zéro ou plusieurs instructions Perl. Ceux-ci peuvent être impératifs normaux
instructions, y compris les étiquettes facultatives, ou les déclarations qui ont un temps de compilation
effet, ou tout mélange de ceux-ci. La séquence d'instructions se termine lorsqu'une accolade fermante
ou une fin de fichier est rencontrée à un endroit où une nouvelle déclaration aurait pu valablement
a débuté. Il appartient à l'appelant de s'assurer que l'état de l'analyseur dynamique
("PL_parser" et al) est correctement défini pour refléter la source du code à être
analysé et le contexte lexical des déclarations.

L'arborescence des opérations représentant la séquence d'instructions est renvoyée. C'est peut-être nul
pointeur si les instructions étaient toutes nulles, par exemple s'il n'y avait pas d'instructions
ou s'il n'y avait que des définitions de sous-programmes (qui ont un côté temps de compilation
effets). S'il n'est pas nul, ce sera une liste "lineseq", comprenant normalement
"nextstate" ou opérations équivalentes.

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, un arbre d'opérations valide est
retourné quand même. L'erreur est reflétée dans l'état de l'analyseur, résultant normalement
dans une seule exception au plus haut niveau d'analyse qui couvre toute la compilation
erreurs qui se sont produites. Certaines erreurs de compilation, cependant, lèveront une exception
immédiatement.

Le manuel de formation drapeaux Le paramètre est réservé pour une utilisation future et doit toujours être égal à zéro.

OP * parse_stmtseq (indicateurs U32)

parse_termexpr
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Analysez une expression de terme Perl. Cela peut contenir des opérateurs de préséance jusqu'à
les opérateurs d'affectation. L'expression doit être suivie (et donc terminée)
soit par une virgule ou un opérateur de priorité inférieure ou par quelque chose qui serait normalement
terminer une expression telle que le point-virgule. Si drapeaux inclut "PARSE_OPTIONAL"
alors l'expression est facultative, sinon elle est obligatoire. C'est à la
l'appelant pour s'assurer que l'état de l'analyseur dynamique ("PL_parser" et al) est correctement
défini pour refléter la source du code à analyser et le contexte lexical du
expression.

L'arborescence des opérations représentant l'expression est renvoyée. Si une expression facultative est
absent, un pointeur nul est renvoyé, sinon le pointeur sera non nul.

Si une erreur se produit lors de l'analyse ou de la compilation, dans la plupart des cas, un arbre d'opérations valide est
retourné quand même. L'erreur est reflétée dans l'état de l'analyseur, résultant normalement
dans une seule exception au plus haut niveau d'analyse qui couvre toute la compilation
erreurs qui se sont produites. Certaines erreurs de compilation, cependant, lèveront une exception
immédiatement.

OP * parse_termexpr (indicateurs U32)

analyseur_PL
Pointeur vers une structure encapsulant l'état de l'opération d'analyse en cours
en cours. Le pointeur peut être modifié localement pour effectuer une analyse imbriquée sans
interférer avec l'état d'une analyse externe. Membres individuels de "PL_parser"
avoir sa propre documentation.

PL_parser->bufend
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Pointeur direct vers la fin du morceau de texte en cours de lexique, la fin de
le tampon lexer. Ceci est égal à "SvPVX(PL_parser->linestr) +
SvCUR(PL_parser->linestr)". Un caractère "NUL" (zéro octet) est toujours situé à
la fin du tampon et ne compte pas dans le contenu du tampon.

PL_parser->bufptr
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Pointe vers la position actuelle de lexing à l'intérieur du tampon lexer. Personnages
autour de ce point peut être librement examiné, dans la plage délimitée par
"SvPVX("PL_parser->linestr")" et "PL_parser->bufend". Les octets du tampon
peut être destiné à être interprété comme UTF-8 ou Latin-1, comme indiqué par
"lex_bufutf8".

Le code Lexing (qu'il soit dans le noyau Perl ou non) déplace ce pointeur au-delà du
caractères qu'il consomme. Il est également prévu d'effectuer une certaine comptabilité
chaque fois qu'un caractère de nouvelle ligne est consommé. Ce mouvement peut être plus commodément
effectuée par la fonction "lex_read_to", qui gère les nouvelles lignes de manière appropriée.

L'interprétation des octets du tampon peut être extraite en utilisant le légèrement
fonctions de niveau supérieur "lex_peek_unichar" et "lex_read_unichar".

PL_parser->linestart
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Pointe vers le début de la ligne actuelle à l'intérieur du tampon lexer. C'est utile
pour indiquer à quelle colonne une erreur s'est produite, et pas grand-chose d'autre. Cela doit être
mis à jour par n'importe quel code lexing qui consomme une nouvelle ligne ; la fonction "lex_read_to"
gère ce détail.

PL_parser->linestr
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Scalaire tampon contenant le morceau actuellement en cours d'examen du texte
en cours de lexage. Il s'agit toujours d'une chaîne scalaire simple (pour laquelle "SvPOK" est
vrai). Il n'est pas destiné à être utilisé comme scalaire par des moyens scalaires normaux ; plutôt
se référer directement au tampon par les variables de pointeur décrites ci-dessous.

Le lexer maintient divers pointeurs "char*" vers des éléments du "PL_parser->linestr"
amortir. Si "PL_parser->linestr" est réalloué, tous ces pointeurs doivent
être mis à jour. N'essayez pas de le faire manuellement, mais utilisez plutôt "lex_grow_linestr"
si vous devez réaffecter le tampon.

Le contenu du morceau de texte dans le tampon est généralement exactement une ligne complète
d'entrée, jusqu'à et y compris un terminateur de nouvelle ligne, mais il y a des situations où
il en est autrement. Les octets du tampon peuvent être destinés à être interprétés comme
soit UTF-8, soit Latin-1. La fonction "lex_bufutf8" vous dit laquelle. Ne pas utiliser
le drapeau "SvUTF8" sur ce scalaire, qui peut être en désaccord avec lui.

Pour un examen direct du tampon, la variable "PL_parser->bufend" pointe vers
la fin du tampon. La position de lexing actuelle est indiquée par
"PL_parser->bufptr". L'utilisation directe de ces pointeurs est généralement préférable à
examen du scalaire par des moyens scalaires normaux.

Lié aux paramètres régionaux fonctions et macros

DECLARATION_FOR_LC_NUMERIC_MANIPULATION
Cette macro doit être utilisée comme une instruction. Il déclare une variable privée (dont
nom commence par un trait de soulignement) nécessaire aux autres macros de ce
section. Ne pas l'inclure correctement devrait entraîner une erreur de syntaxe. Pour
compatibilité avec les compilateurs C C89, il doit être placé dans un bloc avant tout
déclarations exécutables.

annuler DECLARATION_FOR_LC_NUMERIC_MANIPULATION

RESTORE_LC_NUMERIC
Ceci est utilisé en conjonction avec l'une des macros
"STORE_LC_NUMERIC_SET_TO_NEEDED" et "STORE_LC_NUMERIC_FORCE_TO_UNDERLYING"

pour restaurer correctement l'état "LC_NUMERIC".

Un appel à "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" doit avoir été fait pour déclarer
à la compilation une variable privée utilisée par cette macro et les deux "STORE".
Cette macro doit être appelée comme une instruction unique, pas comme une expression, mais avec un
liste d'arguments vide, comme ceci :

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

annuler RESTORE_LC_NUMERIC()

STORE_LC_NUMERIC_FORCE_TO_UNDERLYING
Ceci est utilisé par le code XS qui est compatible avec les paramètres régionaux "LC_NUMERIC" pour forcer les paramètres régionaux
pour que la catégorie "LC_NUMERIC" soit ce que perl pense être la locale sous-jacente actuelle.
(L'interpréteur perl peut se tromper sur ce qu'est réellement la locale sous-jacente
si du code C ou XS a appelé la fonction de la bibliothèque C définirlocale(3) derrière son
arrière; appeler "sync_locale" avant d'appeler cette macro mettra à jour les enregistrements de perl.)

Un appel à "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" doit avoir été fait pour déclarer
au moment de la compilation une variable privée utilisée par cette macro. Cette macro doit être
appelée comme une instruction unique, pas une expression, mais avec une liste d'arguments vide,
comme ça:

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

La variable privée est utilisée pour enregistrer l'état actuel des paramètres régionaux, de sorte que le
l'appel correspondant requis à "RESTORE_LC_NUMERIC" peut le restaurer.

annuler STORE_LC_NUMERIC_FORCE_TO_UNDERLYING()

STORE_LC_NUMERIC_SET_TO_NEEDED
Ceci est utilisé pour aider à envelopper le code XS ou C qui est compatible avec les paramètres régionaux "LC_NUMERIC".
Cette catégorie locale est généralement maintenue définie sur la locale C par Perl pour l'envers.
compatibilité, et parce que la plupart des codes XS qui lisent des valeurs à virgule flottante peuvent faire face
uniquement avec le caractère décimal de base étant un point.

Cette macro s'assure que l'état "LC_NUMERIC" actuel est défini correctement, pour être conscient
de locale si l'appel au code XS ou C depuis le programme Perl provient de
portée d'un "use locale" ; ou pour ignorer les paramètres régionaux si l'appel provient plutôt de l'extérieur
une telle portée.

Cette macro est le début de l'encapsulation du code C ou XS ; la fin du wrap se fait par
appel de la macro "RESTORE_LC_NUMERIC" après l'opération. Sinon l'état
peut être modifié, ce qui affectera négativement d'autres codes XS.

Un appel à "DECLARATION_FOR_LC_NUMERIC_MANIPULATION" doit avoir été fait pour déclarer
au moment de la compilation une variable privée utilisée par cette macro. Cette macro doit être
appelée comme une instruction unique, pas une expression, mais avec une liste d'arguments vide,
comme ça:

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

annuler STORE_LC_NUMERIC_SET_TO_NEEDED()

sync_locale
La modification des paramètres régionaux du programme doit être évitée par le code XS. Néanmoins, certains
les bibliothèques non Perl appelées depuis XS, telles que "Gtk", le font. Lorsque cela se produit, Perl
doit être informé que les paramètres régionaux ont changé. Utilisez cette fonction pour le faire, avant
retour à Perl.

annuler sync_locale()

Magical Les fonctions

mg_clear
Effacer quelque chose de magique que le SV représente. Voir "sv_magic".

entier mg_clear(SV* sv)

mg_copy Copie la magie d'un SV à un autre. Voir "sv_magic".

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

mg_find Trouve le pointeur magique pour le type correspondant au SV. Voir "sv_magic".

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

mg_findext
Trouve le pointeur magique de "type" avec le "vtbl" donné pour le "SV". Voir
"sv_magicext".

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

mg_free Libère tout stockage magique utilisé par le SV. Voir "sv_magic".

entier mg_free(SV* sv)

mg_free_type
Supprimez toute magie de type how de la SV sv. Voir "sv_magic".

void mg_free_type(SV *sv, int comment)

mg_get Faire de la magie avant qu'une valeur ne soit extraite du SV. Le type de SV doit être >=
SVt_PVMG. Voir "sv_magic".

entier mg_get(SV* sv)

mg_longueur
DÉCONSEILLÉ ! Il est prévu de supprimer cette fonction d'une future version de Perl.
Ne l'utilisez pas pour un nouveau code ; le supprimer du code existant.

Rapporte la longueur du SV en octets, appelant la longueur magique si disponible, mais ne
pas défini le drapeau UTF8 sur le sv. Il reviendra à 'obtenir' de la magie s'il n'y a pas
la magie 'longueur', mais sans indication quant à savoir si elle appelait la magie 'get'. Ce
suppose que le sv est un PVMG ou supérieur. Utiliser sv_len() à la place.

U32 mg_length(SV* sv)

mg_magique
Active le statut magique d'un SV. Voir "sv_magic".

annuler mg_magique(SV* sv)

mg_set Faire de la magie après qu'une valeur a été assignée au SV. Voir "sv_magic".

entier mg_set(SV* sv)

SvGETMAGIC
Invoque "mg_get" sur un SV s'il a la magie "get". Par exemple, cela appellera
"FETCH" sur une variable liée. Cette macro évalue son argument plus d'une fois.

annuler SvGETMAGIC(SV* sv)

SvLOCK S'arrange pour qu'un verrou d'exclusion mutuelle soit obtenu sur sv si un module approprié a
été chargé.

annuler SvLOCK(SV* sv)

SvSETMAGIC
Invoque "mg_set" sur un SV s'il a la magie "set". Ceci est nécessaire après
modifier un scalaire, au cas où il s'agirait d'une variable magique comme $| ou une variable liée
(il s'appelle "STORE"). Cette macro évalue son argument plus d'une fois.

annuler SvSETMAGIC(SV* sv)

SvSetMagicSV
Comme "SvSetSV", mais fait toute magie d'ensemble requise par la suite.

annuler SvSetMagicSV(SV* dsv, SV* ssv)

SvSetMagicSV_nosteal
Comme "SvSetSV_nosteal", mais fait toute magie d'ensemble requise par la suite.

annuler SvSetMagicSV_nosteal(SV* dsv, SV* ssv)

SvSetSV Appelle "sv_setsv" si dsv n'est pas identique à ssv. Peut évaluer des arguments plus que
une fois que. Ne gère pas la magie 'set' sur la destination SV.

annuler SvSetSV(SV* dsv, SV* ssv)

SvSetSV_nosteal
Appelle une version non destructive de "sv_setsv" si dsv n'est pas identique à ssv. Mai
évaluer les arguments plus d'une fois.

annuler SvSetSV_nosteal(SV* dsv, SV* ssv)

SvSHARE S'arrange pour que sv soit partagé entre les threads si un module approprié a été chargé.

annuler SvSHARE(SV* sv)

SvUNLOCK
Libère un verrou d'exclusion mutuelle sur sv si un module approprié a été chargé.

annuler SvUNLOCK(SV* sv)

Mémoire Management

Copiez l'interface du XSUB-writer dans la fonction C "memcpy". Le "src" est la source,
"dest" est la destination, "nitems" est le nombre d'éléments et "type" est le
taper. Peut échouer sur des copies qui se chevauchent. Voir aussi "Déplacer".

void Copie (void* src, void* dest, int nitems, type)

CopyD Comme "Copy" mais renvoie dest. Utile pour encourager les compilateurs à faire un appel final
optimiser.

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

Déplacez l'interface du XSUB-writer vers la fonction C "memmove". Le "src" est la source,
"dest" est la destination, "nitems" est le nombre d'éléments et "type" est le
taper. Peut faire des mouvements qui se chevauchent. Voir aussi "Copier".

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

MoveD Comme "Move" mais renvoie dest. Utile pour encourager les compilateurs à faire un appel final
optimiser.

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

Newx L'interface du rédacteur XSUB avec la fonction C "malloc".

La mémoire ainsi obtenue devrait UNIQUEMENT être libéré avec "Safefree".

En 5.9.3, Nouveaux() et les amis remplacent les anciens Nouveau () API, et abandonne le premier
paramètre, x, une aide au débogage qui permettait aux appelants de s'identifier. Cette aide
a été remplacée par une nouvelle option de construction, PERL_MEM_LOG (voir "PERL_MEM_LOG" dans
perlhacktips). L'ancienne API est toujours là pour être utilisée dans les modules XS prenant en charge
perles plus anciennes.

void Newx (void* ptr, int nitems, type)

Newxc L'interface du XSUB-writer à la fonction C "malloc", avec cast. Voir également
"Newx".

La mémoire ainsi obtenue devrait UNIQUEMENT être libéré avec "Safefree".

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

Newxz L'interface du rédacteur XSUB avec la fonction C "malloc". La mémoire allouée est
mis à zéro avec "memzero". Voir aussi "Newx".

La mémoire ainsi obtenue devrait UNIQUEMENT être libéré avec "Safefree".

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

Poison PoisonAvec(0xEF) pour attraper l'accès à la mémoire libérée.

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

Sans poison
PoisonAvec(0xEF) pour attraper l'accès à la mémoire libérée.

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

PoisonNouveau
PoisonAvec(0xAB) pour intercepter l'accès à la mémoire allouée mais non initialisée.

void PoisonNew (void* dest, int nitems, type)

PoisonAvec
Remplir la mémoire avec un modèle d'octet (un octet répété encore et encore) qui
avec un peu de chance, attrape les tentatives d'accès à la mémoire non initialisée.

void PoisonWith(void* dest, int nitems, type,
octet U8)

Renouveler L'interface du rédacteur XSUB avec la fonction C "realloc".

La mémoire ainsi obtenue devrait UNIQUEMENT être libéré avec "Safefree".

void Renouveler(void* ptr, int nitems, type)

Renewc L'interface du XSUB-writer à la fonction C "realloc", avec cast.

La mémoire ainsi obtenue devrait UNIQUEMENT être libéré avec "Safefree".

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

Sans coffre-fort
L'interface du XSUB-writer avec la fonction C "free".

Cela devrait UNIQUEMENT être utilisé sur la mémoire obtenue en utilisant "Newx" et ses amis.

void Safefree(void* ptr)

savepv Version Perl de "strdup()". Renvoie un pointeur vers une chaîne nouvellement allouée qui
est un doublon de "pv". La taille de la chaîne est déterminée par "strlen()", qui
signifie qu'il ne peut pas contenir de caractères "NUL" intégrés et doit avoir un "NUL" à la fin.
La mémoire allouée pour la nouvelle chaîne peut être libérée avec le "Safefree()"
la fonction.

Sur certaines plates-formes, Windows par exemple, toute la mémoire allouée appartenant à un thread est
désalloué lorsque ce thread se termine. Donc, si vous avez besoin que cela ne se produise pas, vous devez
utiliser les fonctions de mémoire partagée, telles que "savesharedpv".

char* savepv(const char* pv)

savepvn La version de Perl de ce que serait "strndup()" s'il existait. Renvoie un pointeur vers un
chaîne nouvellement allouée qui est un doublon des premiers octets "len" de "pv",
plus un octet "NUL" de fin. La mémoire allouée pour la nouvelle chaîne peut être libérée
avec la fonction "Safefree()".

Sur certaines plates-formes, Windows par exemple, toute la mémoire allouée appartenant à un thread est
désalloué lorsque ce thread se termine. Donc, si vous avez besoin que cela ne se produise pas, vous devez
utiliser les fonctions de mémoire partagée, telles que "savesharedpvn".

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

savepvs Comme "savepvn", mais prend une chaîne littérale terminée par "NUL" au lieu d'un
paire chaîne/longueur.

char* savepvs(const char* s)

enregistrerpartagépv
Une version de "savepv()" qui alloue la chaîne dupliquée en mémoire qui est
partagé entre les threads.

char* savesharedpv(const char* pv)

sauvegarderpvn partagé
Une version de "savepvn()" qui alloue la chaîne dupliquée en mémoire qui est
partagé entre les threads. (Avec la différence spécifique qu'un pointeur NULL n'est pas
acceptable)

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

enregistrersharedpvs
Une version de "savepvs()" qui alloue la chaîne dupliquée en mémoire qui est
partagé entre les threads.

char* savesharedpvs(const char* s)

enregistrerpartagésvpv
Une version de "savesharedpv()" qui alloue la chaîne dupliquée en mémoire qui
est partagé entre les threads.

char* savesharedsvpv(SV *sv)

sauvevpv
Une version de "savepv()"/"savepvn()" qui récupère la chaîne à dupliquer à partir du
passé en SV en utilisant "SvPV()"

Sur certaines plates-formes, Windows par exemple, toute la mémoire allouée appartenant à un thread est
désalloué lorsque ce thread se termine. Donc, si vous avez besoin que cela ne se produise pas, vous devez
utiliser les fonctions de mémoire partagée, telles que "savesharedsvpv".

char* sauvevpv(SV* sv)

StructureCopie
Il s'agit d'une macro indépendante de l'architecture pour copier une structure dans une autre.

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

Zero L'interface du XSUB-writer avec la fonction C "memzero". Le "dest" est le
destination, "nitems" est le nombre d'éléments et "type" est le type.

void Zero (void* destination, int nitems, type)

ZeroD Comme "Zero" mais renvoie dest. Utile pour encourager les compilateurs à faire un appel final
optimiser.

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

Divers Les fonctions

dump_c_backtrace
Vide la trace C vers le fp donné.

Renvoie true si une trace arrière a pu être récupérée, false sinon.

bool dump_c_backtrace(PerlIO* fp, int max_degree,
saut int)

fbm_compile
Analyse la chaîne afin d'y effectuer des recherches rapides à l'aide de fbm_instr() -- le
Algorithme de Boyer-Moore.

void fbm_compile(SV* sv, drapeaux U32)

fbm_instr
Renvoie l'emplacement de la SV dans la chaîne délimitée par "big" et "bigend". Ce
renvoie "NULL" si la chaîne est introuvable. Le "sv" n'a pas à être
fbm_compiled, mais la recherche ne sera alors pas aussi rapide.

char* fbm_instr(car non signé* gros,
caractère non signé* bigend, SV* littlestr,
drapeaux U32)

foldEQ Renvoie vrai si les octets de tête des chaînes s1 et s2 ont la même casse.
insensiblement; faux sinon. Les octets de plage ASCII majuscules et minuscules correspondent
eux-mêmes et leurs homologues du cas opposé. Gamme sans casse et sans ASCII
les octets ne correspondent qu'à eux-mêmes.

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

FoldEQ_locale
Renvoie vrai si les octets de tête des chaînes s1 et s2 ont la même casse.
insensiblement dans les paramètres régionaux actuels ; faux sinon.

I32foldEQ_locale(const char* a, const char* b,
Objectif I32)

form Prend un modèle de format de style sprintf et des arguments conventionnels (non-SV) et
renvoie la chaîne formatée.

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

peut être utilisé partout où une chaîne (char *) est requise :

char * s = Perl_form("%d.%d",majeur,mineur);

Utilise un seul tampon privé, donc si vous voulez formater plusieurs chaînes, vous devez
copiez explicitement les chaînes précédentes (et libérez les copies lorsque vous avez terminé).

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

getcwd_sv
Remplissez le sv avec le répertoire de travail actuel

int getcwd_sv(SV* sv)

get_c_backtrace_dump
Renvoie un SV un vidage de |profondeur| trames de la pile d'appels, en sautant le |skip|
les plus intimes. une profondeur de 20 est généralement suffisante.

La sortie jointe ressemble à :

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

Les champs sont séparés par des tabulations. La première colonne est la profondeur (zéro étant la
cadre non sauté le plus à l'intérieur). Dans le hex:offset, l'hex est l'endroit où le programme
compteur était dans S_parse_body, et le :offset (peut-être manquant) indique combien
à l'intérieur du S_parse_body se trouvait le compteur de programme.

util.c:1716 est le fichier de code source et le numéro de ligne.

Le manuel de formation /usr/bin/perl est évident (espérons-le).

Les inconnues sont "-". Les inconnues peuvent arriver malheureusement assez facilement : si la plateforme
ne prend pas en charge la récupération des informations ; si le binaire manque le débogage
information; si l'optimiseur a transformé le code par exemple par inlining.

SV* get_c_backtrace_dump(int max_depth, int sauter)

ibcmp C'est un synonyme de (! plierEQ())

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

ibcmp_locale
C'est un synonyme de (! FoldEQ_locale())

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

is_safe_syscall
Testez que le "pv" donné ne contient aucun caractère "NUL" interne. Si ça
fait, définissez "errno" sur ENOENT, éventuellement avertir et renvoyer FALSE.

Renvoie TRUE si le nom est sûr.

Utilisé par le IS_SAFE_SYSCALL() macro.

bool is_safe_syscall(const char *pv, STRLEN len,
caractère const * quoi,
caractère const *op_name)

memEQ Teste deux tampons (qui peuvent contenir des caractères "NUL" intégrés, pour voir s'ils sont
égal. Le paramètre "len" indique le nombre d'octets à comparer. Retour
zéro si égal, ou non nul si non égal.

booléen memEQ(car* s1, car* s2, STRLEN len)

memNE Testez deux tampons (qui peuvent contenir des caractères "NUL" intégrés, pour voir s'ils sont
inégal. Le paramètre "len" indique le nombre d'octets à comparer. Retour
zéro si non égal, ou non nul si égal.

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

mess Prend un modèle de format de style sprintf et une liste d'arguments. Ceux-ci sont utilisés pour générer
un message de chaîne. Si le message ne se termine pas par une nouvelle ligne, il sera
étendu avec une indication de l'emplacement actuel dans le code, comme décrit
pour "mess_sv".

Normalement, le message résultant est renvoyé dans un nouveau SV mortel. Au cours mondial
destruction une seule SV peut être partagée entre les utilisations de cette fonction.

SV * mess(car const *pat, ...)

mess_sv Développe un message, destiné à l'utilisateur, pour inclure une indication de la
emplacement dans le code, si le message ne semble pas déjà complet.

"basemsg" est le message ou l'objet initial. S'il s'agit d'une référence, elle sera utilisée
tel quel et sera le résultat de cette fonction. Sinon, il est utilisé comme une chaîne,
et s'il se termine déjà par une nouvelle ligne, il est considéré comme complet, et le résultat
de cette fonction sera la même chaîne. Si le message ne se termine pas par un
nouvelle ligne, puis un segment tel que "at foo.pl ligne 37" sera ajouté, et éventuellement
d'autres clauses indiquant l'état actuel de l'exécution. Le message résultant
se terminera par un point et une nouvelle ligne.

Normalement, le message résultant est renvoyé dans un nouveau SV mortel. Au cours mondial
destruction une seule SV peut être partagée entre les utilisations de cette fonction. Si "consommer"
est vrai, alors la fonction est autorisée (mais pas obligatoire) à modifier et à retourner
"basemsg" au lieu d'allouer un nouveau SV.

SV * mess_sv(SV *basemsg, bool consomme)

mon_snprintf
La fonctionnalité "snprintf" de la bibliothèque C, si elle est disponible et conforme aux normes (utilise
"vsnprintf", en fait). Cependant, si le "vsnprintf" n'est pas disponible,
malheureusement, utilisez le "vsprintf" dangereux qui peut saturer le tampon (il existe un
contrôle de dépassement, mais c'est peut-être trop tard). Envisagez d'utiliser "sv_vcatpvf" à la place, ou
obtenir "vsnprintf".

int my_snprintf(char *buffer, const Size_t len,
caractère const *format, ...)

mon_sprintf
La bibliothèque C "sprintf", encapsulée si nécessaire, pour s'assurer qu'elle renverra le
longueur de la chaîne écrite dans le tampon. Seuls les rares systèmes pré-ANSI ont besoin du
fonction wrapper - il s'agit généralement d'un appel direct à "sprintf".

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

mon_strlcat
La bibliothèque C "strlcat" si disponible, ou une implémentation Perl de celle-ci. Ce
fonctionne sur des chaînes C terminées par "NUL".

"my_strlcat()" ajoute la chaîne "src" à la fin de "dst". Il ajoutera au plus
"taille - strlen(dst) - 1" caractères. Il se terminera alors par "NUL", à moins que "size"
est 0 ou la chaîne "dst" d'origine était plus longue que "size" (en pratique, cela devrait
ne se produise pas car cela signifie que "taille" est incorrecte ou que "dst" n'est pas un
propre chaîne terminée par "NUL").

Notez que "taille" est la taille totale du tampon de destination et le résultat est
garanti d'être terminé par "NUL" s'il y a de la place. A noter qu'il y a de la place pour le "NUL"
doit être inclus dans "taille".

Size_t my_strlcat(char *dst, const char *src,
Taille_t taille)

mon_strlcpy
La bibliothèque C "strlcpy" si disponible, ou une implémentation Perl de celle-ci. Ce
fonctionne sur des chaînes C terminées par "NUL".

"my_strlcpy()" copie jusqu'à "size - 1" caractères de la chaîne "src" vers "dst",
"NUL" - termine le résultat si "taille" n'est pas 0.

Size_t my_strlcpy(char *dst, const char *src,
Taille_t taille)

mon_vsnprintf
La bibliothèque C "vsnprintf" si disponible et conforme aux normes. Cependant, si si
le "vsnprintf" n'est pas disponible, utilisera malheureusement le "vsprintf" dangereux
qui peut saturer le tampon (il y a un contrôle de dépassement, mais c'est peut-être trop
en retard). Envisagez d'utiliser "sv_vcatpvf" à la place ou d'obtenir "vsnprintf".

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

PERL_SYS_INIT
Fournit une mise au point spécifique au système de l'environnement d'exécution C nécessaire à l'exécution
Interprètes Perl. Cela ne devrait être appelé qu'une seule fois, avant de créer un Perl
interprètes.

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

PERL_SYS_INIT3
Fournit une mise au point spécifique au système de l'environnement d'exécution C nécessaire à l'exécution
Interprètes Perl. Cela ne devrait être appelé qu'une seule fois, avant de créer un Perl
interprètes.

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

PERL_SYS_TERM
Fournit un nettoyage spécifique au système de l'environnement d'exécution C après l'exécution de Perl
interprètes. Cela ne devrait être appelé qu'une seule fois, après avoir libéré tout Perl restant
interprètes.

annuler PERL_SYS_TERM()

quadmath_format_needed
quadmath_format_needed() renvoie true si la chaîne de format semble contenir au
au moins un spécificateur de format %[efgaEFGA] sans préfixe Q, ou renvoie false dans le cas contraire.

La détection du spécificateur de format n'est pas une détection complète de la syntaxe printf, mais elle
devrait attraper les cas les plus courants.

Si true est renvoyé, ces arguments devrait en théorie être traité avec
quadmath_snprintf(), mais s'il existe plusieurs spécificateurs de format de ce type (voir
"quadmath_format_single"), et s'il y a autre chose au-delà de celui-là (même
un seul octet), ils ne peut pas être traité parce que quadmath_snprintf() est très
strict, n'acceptant qu'une seule spécification de format, et rien d'autre. Dans ce cas, le code
devrait probablement échouer.

bool quadmath_format_needed (format const char*)

quadmath_format_single
quadmath_snprintf() est très strict sur sa chaîne de format et échouera,
renvoie -1, si le format n'est pas valide. Il accepte exactement une spécification de format.

quadmath_format_single() vérifie que la spécification unique prévue semble saine : commence
avec "%", n'a qu'un seul "%", se termine par "[efgaEFGA]", et est précédé d'un "Q". Ce
n'est pas une "vérification complète de la syntaxe printf", juste les bases.

Renvoie le format s'il est valide, NULL sinon.

quadmath_format_single() peut et va effectivement patcher le "Q" manquant, si
nécessaire. Dans ce cas, il renverra la copie modifiée du format, qui le
votre interlocuteur vont need à libres.

Voir aussi "quadmath_format_needed".

const char* quadmath_format_single(const char* format)

READ_XDIGIT
Renvoie la valeur d'un chiffre hexadécimal de plage ASCII et fait avancer le pointeur de chaîne.
Le comportement n'est bien défini que lorsque isXDIGIT(*str) est vrai.

U8 READ_XDIGIT(char str*)

strEQ Teste deux chaînes pour voir si elles sont égales. Renvoie vrai ou faux.

booléen strEQ(car* s1, car* s2)

strGE Testez deux chaînes pour voir si la première, "s1", est supérieure ou égale à la
deuxièmement, "s2". Renvoie vrai ou faux.

booléen strGE(car* s1, car* s2)

strGT Testez deux chaînes pour voir si la première, "s1", est supérieure à la seconde, "s2".
Renvoie vrai ou faux.

booléen strGT(car* s1, car* s2)

strLE Testez deux chaînes pour voir si la première, "s1", est inférieure ou égale à la seconde,
"s2". Renvoie vrai ou faux.

booléen strLE(car* s1, car* s2)

strLT Teste deux chaînes pour voir si la première, "s1", est inférieure à la seconde, "s2".
Renvoie vrai ou faux.

booléen strLT(car* s1, car* s2)

strNE Testez deux chaînes pour voir si elles sont différentes. Renvoie vrai ou faux.

bool strNE(car* s1, car* s2)

strnEQ Teste deux chaînes pour voir si elles sont égales. Le paramètre "len" indique la
nombre d'octets à comparer. Renvoie vrai ou faux. (Un wrapper pour "strncmp").

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

strnNE Testez deux chaînes pour voir si elles sont différentes. Le paramètre "len" indique la
nombre d'octets à comparer. Renvoie vrai ou faux. (Un wrapper pour "strncmp").

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

sv_destroyable
Routine factice qui signale que l'objet peut être détruit lorsqu'il n'y a pas de partage
module présent. Il ignore son seul argument SV et renvoie 'true'. Existe pour
éviter de tester un pointeur de fonction NULL et parce qu'il pourrait potentiellement avertir sous
un certain niveau de rigueur.

booléen sv_destroyable(SV *sv)

sv_nosharing
Routine factice qui "partage" un SV lorsqu'il n'y a pas de module de partage présent. Ou
le "verrouille". Ou le "déverrouille". En d'autres termes, ignore son seul argument SV.
Existe pour éviter de tester un pointeur de fonction NULL et parce qu'il pourrait potentiellement
avertir sous un certain niveau de rigueur.

annuler sv_nosharing(SV *sv)

vmess "pat" et "args" sont un modèle de format de style sprintf et un argument encapsulé
liste. Ceux-ci sont utilisés pour générer un message de chaîne. Si le message ne se termine pas
avec une nouvelle ligne, puis il sera étendu avec une indication du courant
emplacement dans le code, comme décrit pour "mess_sv".

Normalement, le message résultant est renvoyé dans un nouveau SV mortel. Au cours mondial
destruction une seule SV peut être partagée entre les utilisations de cette fonction.

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

MRO Les fonctions

Ces fonctions sont liées à l'ordre de résolution des méthodes des classes perl

mro_get_linear_isa
Renvoie la linéarisation mro pour le stash donné. Par défaut, ce sera
tout ce que "mro_get_linear_isa_dfs" renvoie à moins qu'un autre MRO ne soit en vigueur pour
la cachette. La valeur de retour est un AV* en lecture seule.

Vous êtes responsable de "SvREFCNT_inc()" sur la valeur de retour si vous envisagez de stocker
il n'importe où de manière semi-permanente (sinon il pourrait être supprimé sous vous le
la prochaine fois que le cache est invalidé).

AV * mro_get_linear_isa (stockage HV *)

mro_method_changed_in
Invalide la mise en cache des méthodes sur toutes les classes enfants du stash donné, de sorte qu'elles
remarquerez peut-être les changements dans celui-ci.

Idéalement, toutes les instances de "PL_sub_generation++" dans la source perl en dehors de mro.c
devrait être remplacé par des appels à this.

Perl gère automatiquement la plupart des manières courantes de redéfinir une méthode.
Cependant, il existe plusieurs façons de modifier une méthode dans une réserve sans le
remarquant le code de cache, auquel cas vous devez appeler cette méthode par la suite :

1) Manipuler directement les entrées HV de cachette à partir du code XS.

2) Affectation d'une référence à une constante scalaire en lecture seule dans une entrée de cachette dans l'ordre
pour créer un sous-programme constant (comme le fait constant.pm).

Cette même méthode est disponible à partir de pure perl via,
"mro::method_changed_in(classname)".

void mro_method_changed_in(HV* réserve)

mro_register
Enregistre un plugin mro personnalisé. Voir perlmroapi pour plus de détails.

void mro_register (const struct mro_alg *mro)

Appel multiple Les fonctions

dMULTICALL
Déclarez des variables locales pour un multiappel. Voir "RAPPELS LÉGERS" dans perlcall.

dMULTICALL ;

APPEL MULTIPLE
Effectuez un rappel léger. Voir "RAPPELS LÉGERS" dans perlcall.

APPEL MULTIPLE ;

POP_MULTICALL
Parenthèse fermante pour un rappel léger. Voir "RAPPELS LÉGERS" dans
appel perl.

POP_MULTICALL ;

PUSH_MULTICALL
Crochet d'ouverture pour un rappel léger. Voir "RAPPELS LÉGERS" dans
appel perl.

PUSH_MULTICALL ;

Numérique fonctions

grok_bin
convertit une chaîne représentant un nombre binaire en forme numérique.

A l'entrée Commencer et * len donner la chaîne à scanner, *drapeaux donne des drapeaux de conversion,
et résultat doit être NULL ou un pointeur vers un NV. Le scan s'arrête à la fin du
chaîne ou le premier caractère invalide. Sauf si "PERL_SCAN_SILENT_ILLDIGIT" est défini
in *drapeaux, la rencontre d'un caractère non valide déclenchera également un avertissement. Au
retourner * len est défini sur la longueur de la chaîne analysée, et *drapeaux donne une sortie
drapeaux.

Si la valeur est <= "UV_MAX", elle est renvoyée sous forme d'UV, les drapeaux de sortie sont clairs,
et rien n'est écrit *résultat. Si la valeur est > UV_MAX "grok_bin" renvoie
UV_MAX, définit "PERL_SCAN_GREATER_THAN_UV_MAX" dans les drapeaux de sortie et écrit le
Valeur à *résultat (ou la valeur est ignorée si résultat est NUL).

Le nombre binaire peut éventuellement être préfixé par "0b" ou "b" sauf si
"PERL_SCAN_DISALLOW_PREFIX" est défini dans *drapeaux à l'entrée. Si
"PERL_SCAN_ALLOW_UNDERSCORES" est défini dans *drapeaux alors le nombre binaire peut utiliser '_'
caractères pour séparer les chiffres.

UV grok_bin(const char* début, STRLEN* len_p,
Drapeaux I32*, NV *résultat)

grok_hex
convertit une chaîne représentant un nombre hexadécimal en forme numérique.

A l'entrée Commencer et *len_p donner la chaîne à scanner, *drapeaux donne des drapeaux de conversion,
et résultat doit être NULL ou un pointeur vers un NV. Le scan s'arrête à la fin du
chaîne ou le premier caractère invalide. Sauf si "PERL_SCAN_SILENT_ILLDIGIT" est défini
in *drapeaux, la rencontre d'un caractère non valide déclenchera également un avertissement. Au
retourner * len est défini sur la longueur de la chaîne analysée, et *drapeaux donne une sortie
drapeaux.

Si la valeur est <= UV_MAX, elle est renvoyée sous forme d'UV, les indicateurs de sortie sont clairs et
rien n'est écrit *résultat. Si la valeur est > UV_MAX "grok_hex" renvoie
UV_MAX, définit "PERL_SCAN_GREATER_THAN_UV_MAX" dans les drapeaux de sortie et écrit le
Valeur à *résultat (ou la valeur est ignorée si résultat est NUL).

Le numéro hexadécimal peut éventuellement être préfixé par "0x" ou "x" à moins que
"PERL_SCAN_DISALLOW_PREFIX" est défini dans *drapeaux à l'entrée. Si
"PERL_SCAN_ALLOW_UNDERSCORES" est défini dans *drapeaux alors le nombre hexadécimal peut utiliser '_'
caractères pour séparer les chiffres.

UV grok_hex(const char* début, STRLEN* len_p,
Drapeaux I32*, NV *résultat)

grok_infnan
Aide pour numéro_grok(), accepte différentes manières d'épeler "infini" ou "pas un
nombre", et renvoie l'une des combinaisons d'indicateurs suivantes :

IS_NUMBER_INFINITE
IS_NUMBER_NAN
IS_NUMBER_INFINITE | IS_NUMBER_NEG
IS_NUMBER_NAN | IS_NUMBER_NEG
0

éventuellement |-ed avec IS_NUMBER_TRAILING.

Si un infini ou un non-nombre est reconnu, le *sp pointera vers un octet
après la fin de la chaîne reconnue. Si la reconnaissance échoue, zéro est
retourné, et le *sp ne bougera pas.

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

numéro_grok
Identique à grok_number_flags() avec des drapeaux mis à zéro.

int grok_number(const char *pv, STRLEN len,
UV *valeurp)

grok_number_flags
Reconnaître (ou non) un nombre. Le type du nombre est retourné (0 si
non reconnu), sinon il s'agit d'une combinaison binaire OU de IS_NUMBER_IN_UV,
IS_NUMBER_GREATER_THAN_UV_MAX, IS_NUMBER_NOT_INT, IS_NUMBER_NEG,
IS_NUMBER_INFINITY, IS_NUMBER_NAN (défini dans perl.h).

Si la valeur du nombre peut tenir dans une UV, elle est renvoyée dans la *valuep
IS_NUMBER_IN_UV sera défini pour indiquer que *valuep est valide, IS_NUMBER_IN_UV
ne sera jamais défini sauf si *valuep est valide, mais *valuep peut avoir été affecté à
pendant le traitement même si IS_NUMBER_IN_UV n'est pas défini au retour. Si la valeurp est
NULL, IS_NUMBER_IN_UV sera défini pour les mêmes cas que lorsque valuep est non NULL,
mais aucune affectation réelle (ou SEGV) ne se produira.

IS_NUMBER_NOT_INT sera défini avec IS_NUMBER_IN_UV si des décimales de fin ont été vues
(auquel cas *valuep donne la vraie valeur tronquée à un entier), et
IS_NUMBER_NEG si le nombre est négatif (auquel cas *valuep contient la valeur absolue
évaluer). IS_NUMBER_IN_UV n'est pas défini si la notation e a été utilisée ou si le nombre est plus grand
qu'un UV.

"flags" n'autorise que "PERL_SCAN_TRAILING", qui autorise les non-numériques
texte sur un autre succès grok, en définissant "IS_NUMBER_TRAILING" sur le résultat.

int grok_number_flags(const char *pv, STRLEN len,
UV *valeurp, drapeaux U32)

grok_numeric_radix
Parcourez et sautez pour un séparateur décimal numérique (base).

booléen grok_numeric_radix(const char **sp,
caractère const *envoyer)

grok_oct
convertit une chaîne représentant un nombre octal en forme numérique.

A l'entrée Commencer et * len donner la chaîne à scanner, *drapeaux donne des drapeaux de conversion,
et résultat doit être NULL ou un pointeur vers un NV. Le scan s'arrête à la fin du
chaîne ou le premier caractère invalide. Sauf si "PERL_SCAN_SILENT_ILLDIGIT" est défini
in *drapeaux, rencontrer un 8 ou un 9 déclenchera également un avertissement. Au retour * len is
défini sur la longueur de la chaîne numérisée, et *drapeaux donne des drapeaux de sortie.

Si la valeur est <= UV_MAX, elle est renvoyée sous forme d'UV, les indicateurs de sortie sont clairs et
rien n'est écrit *résultat. Si la valeur est > UV_MAX "grok_oct" renvoie
UV_MAX, définit "PERL_SCAN_GREATER_THAN_UV_MAX" dans les drapeaux de sortie et écrit le
Valeur à *résultat (ou la valeur est ignorée si résultat est NUL).

Si "PERL_SCAN_ALLOW_UNDERSCORES" est défini dans *drapeaux alors le nombre octal peut utiliser
Caractères '_' pour séparer les chiffres.

UV grok_oct(const char* début, STRLEN* len_p,
Drapeaux I32*, NV *résultat)

isinfnan
Perl_isinfnan() est une fonction utilitaire qui renvoie vrai si l'argument NV est soit
un infini ou un NaN, faux sinon. Pour tester plus en détail, utilisez Perl_isinf()
et Perl_isnan().

C'est aussi l'inverse logique de Perl_isfinite().

booléen isinfnan(NV nv)

Perl_signbit
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Renvoie un entier non nul si le bit de signe d'un NV est défini, et 0 si ce n'est pas le cas.

Si Configure détecte que ce système a un bit de signe() qui fonctionnera avec nos VN, alors
nous l'utilisons simplement via le #define dans perl.h. Sinon, retombe sur ça
la mise en oeuvre. L'utilisation principale de cette fonction est la capture de -0.0.

Notes de configuration : cette fonction s'appelle 'Perl_signbit' au lieu d'un simple
'signbit' car il est facile d'imaginer un système ayant un bit de signe() fonction ou
macro qui ne fonctionne pas avec notre choix particulier de NV. Nous ne devrions pas
re-#define signbit comme Perl_signbit et attendez-vous à ce que les en-têtes système standard
Soyez heureux. De plus, il s'agit d'une fonction sans contexte (pas de pTHX_) car Perl_signbit()
est généralement redéfini dans perl.h comme un simple appel de macro au système bit de signe().
Les utilisateurs doivent toujours appeler Perl_signbit().

int Perl_signbit(NV f)

scan_bin
Pour la rétrocompatibilité. Utilisez "grok_bin" à la place.

NV scan_bin(const car* start, STRLEN len,
STRLEN* relen)

scan_hex
Pour la rétrocompatibilité. Utilisez "grok_hex" à la place.

NV scan_hex(const car* start, STRLEN len,
STRLEN* relen)

scan_oct
Pour la rétrocompatibilité. Utilisez "grok_oct" à la place.

NV scan_oct(const car* start, STRLEN len,
STRLEN* relen)

Obsolète en arrière compatibilité fonctions

Certains d'entre eux sont également obsolètes. Vous pouvez les exclure de votre Perl compilé en
en ajoutant cette option à Configure : "-Accflags='-DNO_MATHOMS'"

personnalisé_op_desc
Renvoie la description d'une opération personnalisée donnée. Ceci était autrefois utilisé par l'OP_DESC
macro, mais ne l'est plus : elle n'a été conservée que par compatibilité, et ne devrait pas
être utilisé.

const char * custom_op_desc(const OP *o)

nom_op_personnalisé
Renvoie le nom d'une opération personnalisée donnée. Ceci était autrefois utilisé par la macro OP_NAME,
mais ne l'est plus : il n'a été conservé que par compatibilité, et ne doit pas être utilisé.

const char * nom_op_personnalisé (const OP *o)

méthode gv_fetch
Voir "gv_fetchmethod_autoload".

GV* gv_fetchmethod(HV* réserve, const char* nom)

is_utf8_char
DÉCONSEILLÉ ! Il est prévu de supprimer cette fonction d'une future version de Perl.
Ne l'utilisez pas pour un nouveau code ; le supprimer du code existant.

Teste si un nombre arbitraire d'octets commence par un caractère UTF-8 valide. Noter
qu'un caractère INVARIANT (c'est-à-dire ASCII sur les machines non-EBCDIC) est un UTF-8 valide
personnage. Le nombre réel d'octets dans le caractère UTF-8 sera renvoyé si
il est valide, sinon 0.

Cette fonction est obsolète en raison de la possibilité qu'une entrée incorrecte puisse
provoquer la lecture au-delà de la fin du tampon d'entrée. Utilisez "isUTF8_CHAR" à la place.

STRLEN is_utf8_char(const U8 *s)

is_utf8_char_buf
Ceci est identique à la macro "isUTF8_CHAR".

STRLEN is_utf8_char_buf(const U8 *buf,
const U8 *buf_end)

pack_cat
Le moteur mettant en œuvre paquet() Fonction Perl. Remarque : les paramètres next_in_list et
les drapeaux ne sont pas utilisés. Cet appel ne doit pas être utilisé ; utilisez la liste de paquets à la place.

void pack_cat(SV *cat, const char *pat,
const char *patend, SV **beglist,
SV **liste finale, SV ***liste_suivante,
drapeaux U32)

pad_compname_type
Recherche le type de la variable lexicale à la position po dans le présent-
bloc de compilation. Si la variable est typée, le stash de la classe à laquelle elle est
tapé est renvoyé. Sinon, "NULL" est renvoyé.

HV * pad_compname_type(PADOFFSET po)

sv_2pvbyte_nolen
Renvoie un pointeur vers la représentation codée en octets du SV. Peut causer le SV
être déclassé de UTF-8 comme effet secondaire.

Généralement accessible via la macro "SvPVbyte_nolen".

char* sv_2pvbyte_nolen(SV* sv)

sv_2pvutf8_nolen
Renvoie un pointeur vers la représentation encodée en UTF-8 du SV. Peut causer le SV
être mis à niveau vers UTF-8 comme effet secondaire.

Généralement accessible via la macro "SvPVutf8_nolen".

char* sv_2pvutf8_nolen(SV* sv)

sv_2pv_nolen
Comme "sv_2pv()", mais ne renvoie pas non plus la longueur. Vous devez généralement utiliser le
enveloppe de macro "SvPV_nolen(sv)" à la place.

char* sv_2pv_nolen(SV* sv)

sv_catpvn_mg
Comme "sv_catpvn", mais gère également la magie "set".

void sv_catpvn_mg(SV *sv, const char *ptr,
STRLEN len)

sv_catsv_mg
Comme "sv_catsv", mais gère également la magie "set".

annuler sv_catsv_mg(SV *dsv, SV *ssv)

sv_force_normal
Annulez divers types de fakery sur un SV : si le PV est une chaîne partagée, faites un
copie privée ; si nous sommes un arbitre, arrêtez d'arbitrer ; si nous sommes un glob, rétrogradons vers un xpvmg.
Voir aussi "sv_force_normal_flags".

annuler sv_force_normal(SV *sv)

sv_iv Une implémentation privée de la macro "SvIVx" pour les compilateurs qui ne peuvent pas gérer
macro-expressions complexes. Utilisez toujours la macro à la place.

IV sv_iv(SV* sv)

sv_nolocking
Routine factice qui "verrouille" un SV lorsqu'aucun module de verrouillage n'est présent. Existe
pour éviter de tester un pointeur de fonction NULL et parce qu'il pourrait potentiellement avertir
sous un certain niveau de rigueur.

"Remplacé" par sv_nosharing().

annuler sv_nolocking(SV *sv)

sv_nounlocking
Routine factice qui "déverrouille" un SV lorsqu'il n'y a pas de module de verrouillage présent.
Existe pour éviter de tester un pointeur de fonction NULL et parce qu'il pourrait potentiellement
avertir sous un certain niveau de rigueur.

"Remplacé" par sv_nosharing().

annuler sv_nounlocking(SV *sv)

sv_nv Une implémentation privée de la macro "SvNVx" pour les compilateurs qui ne peuvent pas gérer
macro-expressions complexes. Utilisez toujours la macro à la place.

NV sv_nv(SV* sv)

sv_pv Utilisez plutôt la macro "SvPV_nolen"

car* sv_pv(SV *sv)

sv_pvbyte
Utilisez "SvPVbyte_nolen" à la place.

char* sv_pvbyte(SV *sv)

sv_pvbyte
Une implémentation privée de la macro "SvPVbyte" pour les compilateurs qui ne peuvent pas faire face
avec des macro-expressions complexes. Utilisez toujours la macro à la place.

char* sv_pvbyten(SV *sv, STRLEN *lp)

sv_pvn Une implémentation privée de la macro "SvPV" pour les compilateurs qui ne peuvent pas gérer
macro-expressions complexes. Utilisez toujours la macro à la place.

char* sv_pvn(SV *sv, STRLEN *lp)

sv_pvutf8
Utilisez plutôt la macro "SvPVutf8_nolen"

char* sv_pvutf8(SV *sv)

sv_pvutf8n
Une implémentation privée de la macro "SvPVutf8" pour les compilateurs qui ne peuvent pas faire face
avec des macro-expressions complexes. Utilisez toujours la macro à la place.

char* sv_pvutf8n(SV *sv, STRLEN *lp)

sv_taint
Tache un SV. Utilisez "SvTAINTED_on" à la place.

annuler sv_taint(SV* sv)

sv_unref
Désactive l'état RV du SV et décrémente le nombre de références de tout ce qui était
étant référencé par le RV. Cela peut presque être considéré comme un renversement de
"nouveauSVrv". C'est "sv_unref_flags" avec le "flag" étant zéro. Voir "SvROK_off".

annuler sv_unref(SV* sv)

sv_usepvn
Indique à un SV d'utiliser "ptr" pour trouver sa valeur de chaîne. Mis en œuvre en appelant
"sv_usepvn_flags" avec "flags" de 0, donc ne gère pas la magie 'set'. Voir
"sv_usepvn_flags".

void sv_usepvn(SV* sv, char* ptr, STRLEN len)

sv_usepvn_mg
Comme "sv_usepvn", mais gère également la magie "set".

void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)

sv_uv Une implémentation privée de la macro "SvUVx" pour les compilateurs qui ne peuvent pas gérer
macro-expressions complexes. Utilisez toujours la macro à la place.

UV sv_uv(SV* sv)

décompresser_str
Le moteur mettant en œuvre déballer() Fonction Perl. Remarque : paramètres strbeg, new_s
et ocnt ne sont pas utilisés. Cet appel ne doit pas être utilisé, utilisez plutôt unpackstring.

I32 unpack_str(const char *pat, const char *patend,
caractère const *s, caractère const *strbeg,
const char *strend, char **new_s,
I32 ocnt, drapeaux U32)

utf8_to_uvchr
DÉCONSEILLÉ ! Il est prévu de supprimer cette fonction d'une future version de Perl.
Ne l'utilisez pas pour un nouveau code ; le supprimer du code existant.

Renvoie le point de code natif du premier caractère de la chaîne "s" qui est
supposé être en codage UTF-8 ; "retlen" sera défini sur la longueur, en octets, de
ce personnage.

Certaines malformations UTF-8, mais pas toutes, sont détectées et, en fait, certaines malformations
l'entrée peut entraîner une lecture au-delà de la fin du tampon d'entrée, c'est pourquoi cette
la fonction est obsolète. Utilisez "utf8_to_uvchr_buf" à la place.

Si "s" pointe vers l'une des malformations détectées et que les avertissements UTF8 sont activés,
zéro est renvoyé et *retlen est défini (si "retlen" n'est pas NULL) sur -1. Si ceux
les avertissements sont désactivés, la valeur calculée si elle est bien définie (ou le REMPLACEMENT Unicode
CHARACTER, si ce n'est pas le cas) est retourné silencieusement et *retlen est défini (si "retlen" n'est pas
NULL) de sorte que ("s" + *retlen) soit la prochaine position possible dans "s" qui pourrait
commencer un caractère non malformé. Voir "utf8n_to_uvchr" pour plus de détails sur le moment où le
Le CARACTÈRE DE REMPLACEMENT est renvoyé.

UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)

utf8_to_uvuni
DÉCONSEILLÉ ! Il est prévu de supprimer cette fonction d'une future version de Perl.
Ne l'utilisez pas pour un nouveau code ; le supprimer du code existant.

Renvoie le point de code Unicode du premier caractère de la chaîne "s" qui est
supposé être en codage UTF-8 ; "retlen" sera défini sur la longueur, en octets, de
ce personnage.

Certaines malformations UTF-8, mais pas toutes, sont détectées et, en fait, certaines malformations
l'entrée peut entraîner une lecture au-delà de la fin du tampon d'entrée, ce qui est l'une des raisons
pourquoi cette fonction est obsolète. L'autre est que ce n'est que dans des cas extrêmement limités
circonstances si le point de code Unicode par rapport au code natif présente un intérêt pour
toi. Voir "utf8_to_uvuni_buf" pour les alternatives.

Si "s" pointe vers l'une des malformations détectées et que les avertissements UTF8 sont activés,
zéro est renvoyé et *retlen est défini (si "retlen" ne pointe pas sur NULL) à -1. Si
ces avertissements sont désactivés, la valeur calculée si elle est bien définie (ou l'Unicode
CARACTÈRE DE REMPLACEMENT, si ce n'est pas le cas) est renvoyé silencieusement et *retlen est défini (si
"retlen" n'est pas NULL) de sorte que ("s" + *retlen) est la prochaine position possible dans "s"
qui pourrait commencer un personnage non malformé. Voir "utf8n_to_uvchr" pour plus de détails sur
lorsque le CARACTÈRE DE REMPLACEMENT est renvoyé.

UV utf8_to_uvuni(const U8 *s, STRLEN *retlen)

Optrée construction

nouveauASSIGNOP
Construit, vérifie et renvoie une opération d'affectation. à gauche et bien fournir le
paramètres de la mission ; ils sont consommés par cette fonction et font partie
de l'arbre op construit.

If type d'option est "OP_ANDASSIGN", "OP_ORASSIGN" ou "OP_DORASSIGN", alors un
optree conditionnel est construit. Si type d'option est l'opcode d'un opérateur binaire,
comme "OP_BIT_OR", alors un op est construit qui effectue l'opération binaire
et affecte le résultat à l'argument de gauche. De toute façon, si type d'option n'est pas nul
puis drapeaux n'a aucun effet.

If type d'option est zéro, alors une simple affectation de scalaire ou de liste est construite. Lequel
le type d'affectation dont il s'agit est déterminé automatiquement. drapeaux donne les huit bits
de "op_flags", sauf que "OPf_KIDS" sera défini automatiquement, et, décalé vers le haut
huit bits, les huit bits de "op_private", sauf que le bit de valeur 1 ou 2
est automatiquement défini selon les besoins.

OP * newASSIGNOP (indicateurs I32, OP * gauche, type d'option I32,
OP *à droite)

nouveauBINOP
Construit, vérifie et retourne un op de n'importe quel type binaire. type est l'opcode.
drapeaux donne les huit bits de "op_flags", sauf que "OPf_KIDS" sera défini
automatiquement, et, décalés de huit bits vers le haut, les huit bits de "op_private", sauf
que le bit avec la valeur 1 ou 2 est automatiquement défini selon les besoins. premier et dernier
fournir jusqu'à deux ops pour être les enfants directs de l'op binaire ; ils sont consommés
par cette fonction et faire partie de l'arborescence op construite.

OP * newBINOP(type I32, drapeaux I32, OP *first,
OP *dernier)

nouveauCONDOP
Construit, vérifie et renvoie une expression conditionnelle ("cond_expr") op. drapeaux
donne les huit bits de "op_flags", sauf que "OPf_KIDS" sera défini
automatiquement, et, décalés de huit bits vers le haut, les huit bits de "op_private", sauf
que le bit avec la valeur 1 est automatiquement activé. premier fournit l'expression
la sélection entre les deux branches, et vraiop et tromperie approvisionner les succursales;
ils sont consommés par cette fonction et font partie de l'arborescence op construite.

OP * newCONDOP (indicateurs I32, OP *first, OP *trueop,
OP *fauxop)

nouveauDEFSVOP
Construit et retourne un op pour accéder à $_, soit comme une variable lexicale (si
déclaré comme "my $_") dans la portée actuelle, ou le global $_.

OP * nouveauDEFSVOP()

nouveauFOROP
Construit, vérifie et retourne un arbre op exprimant une boucle "foreach" (itération
via une liste de valeurs). Il s'agit d'une boucle lourde, avec une structure qui permet
sortir de la boucle par "dernier" et ainsi de suite.

sv fournit éventuellement la variable qui sera aliasée à chaque élément tour à tour ; si
null, la valeur par défaut est $_ (soit lexical, soit global). expr fournit la liste des
valeurs à itérer. bloc alimente le corps principal de la boucle, et compte
fournit éventuellement un bloc "continuer" qui fonctionne comme une seconde moitié du corps.
Toutes ces entrées optree sont consommées par cette fonction et font partie du
arbre op construit.

drapeaux donne les huit bits de "op_flags" pour l'op "leaveloop" et, décalé vers le haut
huit bits, les huit bits de "op_private" pour l'op "leaveloop", sauf que (dans
les deux cas), certains bits seront définis automatiquement.

OP * newFOROP (indicateurs I32, OP * sv, OP * expr, OP * block,
OP *suite)

nouveauDONNÉOP
Construit, vérifie et retourne un arbre op exprimant un bloc "donné". cond
fournit l'expression qui sera affectée localement à une variable lexicale, et
bloc fournit le corps de la construction "donnée" ; ils sont consommés par cela
fonctionner et faire partie de l'arborescence op construite. defsv_off est le décalage du pad
de la variable lexicale scalaire qui sera affectée. Si c'est 0, le $_ global
sera utilisé.

OP * nouveauGIVENOP(OP *cond, OP *bloc,
PADOFFSETdefsv_off)

newGVOP Construit, vérifie et renvoie une opération de n'importe quel type qui implique un
référence à un GV. type est l'opcode. drapeaux donne les huit bits de "op_flags".
gv identifie le GV auquel l'op doit faire référence ; l'appel de cette fonction ne
transférer la propriété de toute référence à celui-ci.

OP * newGVOP (type I32, drapeaux I32, GV *gv)

nouveauLISTOP
Construit, vérifie et renvoie une opération de n'importe quel type de liste. type est l'opcode.
drapeaux donne les huit bits de "op_flags", sauf que "OPf_KIDS" sera défini
automatiquement si nécessaire. premier et dernier fournir jusqu'à deux opérations pour être direct
enfants de la liste op; ils sont consommés par cette fonction et font partie du
arbre op construit.

Pour la plupart des opérateurs de liste, la fonction de vérification s'attend à ce que tous les kid ops soient présents
déjà, donc appeler "newLISTOP(OP_JOIN, ...)" (par exemple) n'est pas approprié. Ce que vous
voulez faire dans ce cas est de créer un op de type OP_LIST, ajouter plus d'enfants à
puis appelez "op_convert_list". Voir "op_convert_list" pour plus d'informations.

OP * newLISTOP(type I32, drapeaux I32, OP *premier,
OP *dernier)

nouveauLOGOP
Construit, vérifie et renvoie une opération logique (contrôle de flux). type est l'opcode.
drapeaux donne les huit bits de "op_flags", sauf que "OPf_KIDS" sera défini
automatiquement, et, décalés de huit bits vers le haut, les huit bits de "op_private", sauf
que le bit avec la valeur 1 est automatiquement activé. premier fournit l'expression
contrôler le débit, et d’autres fournit la chaîne d'opérations latérale (alternative); elles ou ils
sont consommés par cette fonction et font partie de l'arborescence op construite.

OP * newLOGOP(type I32, drapeaux I32, OP *premier,
OP *autre)

nouveauLOOPEX
Construit, vérifie et retourne une opération de sortie de boucle (telle que "goto" ou "last").
type est l'opcode. étiquette fournit le paramètre déterminant la cible du
op; il est consommé par cette fonction et fait partie de l'arborescence op construite.

OP * nouveauLOOPEX(type I32, OP *étiquette)

nouveauLOOPOP
Construit, vérifie et retourne un arbre op exprimant une boucle. Ce n'est qu'une boucle
dans le flux de contrôle à travers l'arborescence op ; il n'a pas la boucle lourde
structure qui permet de sortir de la boucle par "dernier" et ainsi de suite. drapeaux donne l'
huit bits de "op_flags" pour l'op de niveau supérieur, sauf que certains bits seront définis
automatiquement selon les besoins. expr fournit la boucle de contrôle d'expression
itération, et bloc alimente le corps de la boucle ; ils sont consommés par cela
fonctionner et faire partie de l'arborescence op construite. débogable est actuellement
inutilisé et devrait toujours être 1.

OP * newLOOPOP(I32 flags, I32 débogable, OP *expr,
OP *bloc)

nouveauMETHOP
Construit, vérifie et renvoie une opération de type de méthode avec un nom de méthode évalué
à l'exécution. type est l'opcode. drapeaux donne les huit bits de "op_flags", sauf
que "OPf_KIDS" sera défini automatiquement, et, décalés de huit bits, les huit
bits de "op_private", sauf que le bit avec la valeur 1 est automatiquement défini.
dynamique_meth fournit une opération qui évalue le nom de la méthode ; il est consommé par cela
fonctionner et faire partie de l'arborescence op construite. Types d'options pris en charge :
OP_MÉTHODE.

OP * newMETHOP (type I32, drapeaux I32, OP * premier)

nouveauMETHOP_named
Construit, vérifie et renvoie une opération de type méthode avec un nom de méthode constant.
type est l'opcode. drapeaux donne les huit bits de "op_flags", et, décalé vers le haut
huit bits, les huit bits de "op_private". const_meth fournit une méthode constante
Nom; il doit s'agir d'une chaîne COW partagée. Optypes pris en charge : OP_METHOD_NAMED.

OP * newMETHOP_named(type I32, drapeaux I32,
SV *const_meth)

nouveauNULLLIST
Construit, vérifie et renvoie une nouvelle opération "stub", qui représente une liste vide
expression.

OP * nouvelleNULLLIST()

newOP Construit, vérifie et retourne un op de n'importe quel type de base (tout type qui n'a pas
des champs). type est l'opcode. drapeaux donne les huit bits de "op_flags", et,
décalé de huit bits, les huit bits de "op_private".

OP * newOP (type I32, drapeaux I32)

nouveauPADOP
Construit, vérifie et retourne une opération de n'importe quel type qui implique une référence à un
élément de tampon. type est l'opcode. drapeaux donne les huit bits de "op_flags". UNE
l'emplacement du pad est automatiquement alloué et est rempli avec sv; cette fonction prend
propriété d'une référence à celui-ci.

Cette fonction n'existe que si Perl a été compilé pour utiliser ithreads.

OP * newPADOP (type I32, drapeaux I32, SV *sv)

newPMOP Construit, vérifie et renvoie un op de n'importe quel type de correspondance de modèle. type est le
code opération. drapeaux donne les huit bits de "op_flags" et, décalé de huit bits, le
huit bits de "op_private".

OP * newPMOP (type I32, drapeaux I32)

newPVOP Construit, vérifie et renvoie une opération de tout type impliquant un
Pointeur de niveau C (PV). type est l'opcode. drapeaux donne les huit bits de
"op_flags". pv fournit le pointeur de niveau C, qui doit avoir été attribué à l'aide
"PerlMemShared_malloc" ; la mémoire sera libérée lorsque l'op sera détruit.

OP * newPVOP (type I32, drapeaux I32, caractère *pv)

nouvelle gamme
Construit et renvoie une opération "range", avec des opérations subordonnées "flip" et "flop".
drapeaux donne les huit bits de "op_flags" pour l'op "flip" et, décalé de huit
bits, les huit bits de "op_private" pour les opérations "flip" et "range", sauf
que le bit avec la valeur 1 est automatiquement activé. à gauche et bien fournir le
expressions contrôlant les extrémités de la plage ; ils sont consommés par cela
fonctionner et faire partie de l'arborescence op construite.

OP * newRANGE (drapeaux I32, OP * gauche, OP * droite)

nouveauSLICEOP
Construit, vérifie et renvoie une opération "lslice" (tranche de liste). drapeaux donne l'
huit bits de "op_flags", sauf que "OPf_KIDS" sera défini automatiquement, et,
décalé de huit bits, les huit bits de "op_private", sauf que le bit avec
la valeur 1 ou 2 est automatiquement définie selon les besoins. listeval et indice fournir le
paramètres de la tranche ; ils sont consommés par cette fonction et font partie du
arbre op construit.

OP * newSLICEOP(indicateurs I32, OP *indice,
OP *listval)

nouveauSTATEOP
Construit un état op (COP). L'opération d'état est normalement une opération "nextstate", mais
être une opération "dbstate" si le débogage est activé pour le code actuellement compilé. L'état
op est renseigné à partir de "PL_curcop" (ou "PL_compiling"). Si étiquette est non nul, il
fournit le nom d'une étiquette à attacher à l'état op ; cette fonction prend
propriété de la mémoire pointée par étiquette, et le libérera. drapeaux donne l'
huit bits de "op_flags" pour l'état op.

If o est nul, l'état op est renvoyé. Sinon, l'état op est combiné avec o
dans une opération de liste "lineseq", qui est renvoyée. o est consommé par cette fonction et
devient une partie de l'arborescence op renvoyée.

OP * newSTATEOP (indicateurs I32, caractère * étiquette, OP * o)

newSVOP Construit, vérifie et renvoie une opération de tout type impliquant une SV intégrée.
type est l'opcode. drapeaux donne les huit bits de "op_flags". sv donne le SV à
intégrer dans l'op ; cette fonction s'approprie une référence à celle-ci.

OP * nouveauSVOP (type I32, drapeaux I32, SV *sv)

newUNOP Construit, vérifie et retourne un op de n'importe quel type unaire. type est l'opcode.
drapeaux donne les huit bits de "op_flags", sauf que "OPf_KIDS" sera défini
automatiquement si nécessaire, et, décalés de huit bits vers le haut, les huit bits de
"op_private", sauf que le bit avec la valeur 1 est automatiquement défini. premier
fournit un op facultatif pour être l'enfant direct de l'op unaire ; il est consommé par
cette fonction et faire partie de l'arborescence op construite.

OP * newUNOP (type I32, drapeaux I32, OP * premier)

nouveauUNOP_AUX
Similaire à "newUNOP", mais crée une structure UNOP_AUX à la place, avec op_aux
initialisé à aux

OP* newUNOP_AUX(type I32, drapeaux I32, OP* premier,
UNOP_AUX_item *aux)

nouveauWHENOP
Construit, vérifie et retourne un arbre op exprimant un bloc "quand". cond
fournit l'expression de test, et bloc fournit le bloc qui sera exécuté
si le test est évalué à vrai ; ils sont consommés par cette fonction et font partie
de l'arbre op construit. cond sera interprété DWIMically, souvent comme un
comparaison avec $_, et peut être nul pour générer un bloc "par défaut".

OP * nouveauWHENOP(OP *cond, OP *bloc)

nouveauWHILEOP
Construit, vérifie et retourne un arbre op exprimant une boucle "while". C'est un
boucle lourde, avec une structure qui permet de sortir de la boucle par "dernier" et
pareil.

boucle est une opération "enterloop" préconstruite facultative à utiliser dans la boucle ; Si c'est
null alors un op approprié sera construit automatiquement. expr fournit le
expression de contrôle de la boucle. bloc alimente le corps principal de la boucle, et compte
fournit éventuellement un bloc "continuer" qui fonctionne comme une seconde moitié du corps.
Toutes ces entrées optree sont consommées par cette fonction et font partie du
arbre op construit.

drapeaux donne les huit bits de "op_flags" pour l'op "leaveloop" et, décalé vers le haut
huit bits, les huit bits de "op_private" pour l'op "leaveloop", sauf que (dans
les deux cas), certains bits seront définis automatiquement. débogable est actuellement inutilisé
et doit toujours valoir 1. a_mon peut être fourni comme vrai pour forcer le corps de la boucle à
être enfermée dans son propre champ d'application.

OP * newWHILEOP(drapeaux I32, débogable I32,
BOUCLE *boucle, OP *expr, OP *bloc,
OP *suite, I32 has_my)

Optrée Manipulation Les fonctions

alloccopstash
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Disponible uniquement sous les builds threadés, cette fonction alloue une entrée dans
"PL_stashpad" pour la réserve qui lui est transmise.

PADOFFSET alloccopstash(HV *hv)

bloc_fin
Gère la sortie de la portée au moment de la compilation. sol est l'index de sauvegarde renvoyé par
"block_start", et suivants est le corps du bloc. Renvoie le bloc, éventuellement
modifié.

OP * block_end (étage I32, OP * seq)

block_start
Gère l'entrée de portée au moment de la compilation. S'arrange pour que les indices soient restaurés à la sortie du bloc
et gère également les numéros de séquence de remplissage pour que la portée des variables lexicales soit correcte.
Renvoie un index de sauvegarde à utiliser avec "block_end".

int block_start (entier complet)

ck_entersub_args_list
Effectue la correction par défaut de la partie arguments d'une arborescence d'opérations "entersub". Ce
consiste à appliquer le contexte de liste à chacune des opérations d'argument. C'est le
traitement standard utilisé sur un appel marqué d'un "&", ou un appel de méthode, ou un appel
via une référence de sous-programme, ou tout autre appel où l'appelé ne peut pas être
identifié au moment de la compilation, ou un appel où l'appelé n'a pas de prototype.

OP * ck_entersub_args_list(OP *entersubop)

ck_entersub_args_proto
Effectue la correction de la partie arguments d'une arborescence d'opérations "entersub" basée sur un
prototype de sous-programme. Cela apporte diverses modifications à l'argument ops, de
appliquer le contexte jusqu'à insérer les opérations "refgen", et vérifier le nombre et
types syntaxiques d'arguments, comme indiqué par le prototype. C'est la norme
traitement utilisé sur un appel de sous-programme, non marqué par "&", où l'appelé peut être
identifié au moment de la compilation et possède un prototype.

protosv fournit le prototype de sous-programme à appliquer à l'appel. Il peut s'agir d'un
scalaire défini normal, dont la valeur de chaîne sera utilisée. Alternativement, pour
Par commodité, il peut s'agir d'un objet de sous-programme (un "CV*" qui a été transtypé en "SV*")
qui a un prototype. Le prototype fourni, sous quelque forme que ce soit, n'a pas besoin
pour correspondre à l'appelé réel référencé par l'arborescence op.

Si l'argument ops n'est pas d'accord avec le prototype, par exemple en ayant un
nombre inacceptable d'arguments, un arbre op valide est quand même renvoyé. L'erreur
est reflété dans l'état de l'analyseur, ce qui entraîne normalement une seule exception à la
niveau supérieur d'analyse qui couvre toutes les erreurs de compilation qui se sont produites. Dans
le message d'erreur, l'appelé est désigné par le nom défini par le nomgv
paramètre.

OP * ck_entersub_args_proto(OP *entersubop,
GV *nomgv, SV *protosv)

ck_entersub_args_proto_or_list
Effectue la correction de la partie arguments d'une arborescence d'opérations "entersub" soit en fonction de
un prototype de sous-programme ou en utilisant le traitement de contexte de liste par défaut. C'est le
traitement standard utilisé sur un appel de sous-programme, non marqué par "&", où le
l'appelé peut être identifié au moment de la compilation.

protosv fournit le prototype de sous-programme à appliquer à l'appel, ou indique
qu'il n'y a pas de prototype. Il peut s'agir d'un scalaire normal, auquel cas s'il est
défini alors la valeur de chaîne sera utilisée comme prototype, et si elle n'est pas définie
alors il n'y a pas de prototype. Alternativement, pour plus de commodité, il peut s'agir d'un
objet de sous-programme (un "CV*" converti en "SV*"), dont le prototype
sera utilisé s'il en a un. Le prototype (ou son absence) fourni, en
quelle que soit la forme, n'a pas besoin de correspondre à l'appelé réel référencé par l'op
arbre.

Si l'argument ops n'est pas d'accord avec le prototype, par exemple en ayant un
nombre inacceptable d'arguments, un arbre op valide est quand même renvoyé. L'erreur
est reflété dans l'état de l'analyseur, ce qui entraîne normalement une seule exception à la
niveau supérieur d'analyse qui couvre toutes les erreurs de compilation qui se sont produites. Dans
le message d'erreur, l'appelé est désigné par le nom défini par le nomgv
paramètre.

OP * ck_entersub_args_proto_or_list(OP *entersubop,
GV *nomgv,
SV *protosv)

cv_const_sv
Si "cv" est un sous constant éligible pour l'inlining, renvoie la valeur constante
renvoyé par le sous-marin. Sinon, renvoie NULL.

Les subs constants peuvent être créés avec "newCONSTSUB" ou comme décrit dans "Constant
Fonctions" dans perlsub.

SV* cv_const_sv(CV const *CV const)

cv_get_call_checker
Récupère la fonction qui sera utilisée pour réparer un appel à cv. Plus précisément,
la fonction est appliquée à un arbre opérationnel "entersub" pour un appel de sous-programme, non marqué
avec "&", où l'appelé peut être identifié au moment de la compilation comme cv.

Le pointeur de fonction de niveau C est renvoyé dans *ckfun_p, et un argument SV pour cela est
rentré dans *ckobj_p. La fonction est destinée à être appelée de cette manière :

entersubop = (*ckfun_p)(aTHX_entersubop, namegv, (*ckobj_p));

Dans cet appel, entersubop est un pointeur vers l'op "entersub", qui peut être remplacé
par la fonction de vérification, et nomgv est un GV fournissant le nom qui doit être utilisé
par la fonction check pour faire référence à l'appelé de l'op "entersub" s'il a besoin de
n'émet aucun diagnostic. Il est permis d'appliquer la fonction de contrôle dans des
situations, telles qu'un appel à un sous-programme différent ou à un appel de méthode.

Par défaut, la fonction est Perl_ck_entersub_args_proto_or_list, et le SV
le paramètre est cv lui-même. Cela implémente le traitement de prototype standard. Ça peut être
changé, pour un sous-programme particulier, par "cv_set_call_checker".

void cv_get_call_checker(CV *cv,
Perl_call_checker *ckfun_p,
SV**ckobj_p)

cv_set_call_checker
La forme originale de "cv_set_call_checker_flags", qui lui passe le
Drapeau "CALL_CHECKER_REQUIRE_GV" pour la rétrocompatibilité.

void cv_set_call_checker(CV *cv,
Perl_call_checker ckfun,
SV *ckobj)

cv_set_call_checker_flags
Définit la fonction qui sera utilisée pour fixer un appel à cv. Plus précisément, le
la fonction est appliquée à un arbre opérationnel "entersub" pour un appel de sous-programme, non marqué
avec "&", où l'appelé peut être identifié au moment de la compilation comme cv.

Le pointeur de fonction de niveau C est fourni dans ckfun, et un argument SV pour cela est
fourni en ckobj. La fonction doit être définie comme ceci :

OP STATIQUE * ckfun(pTHX_ OP *op, GV *namegv, SV *ckobj)

Il est destiné à être appelé de cette manière:

entersubop = ckfun(aTHX_entersubop, namegv, ckobj);

Dans cet appel, entersubop est un pointeur vers l'op "entersub", qui peut être remplacé
par la fonction de vérification, et nomgv fournit le nom qui doit être utilisé par le
vérifier la fonction pour faire référence à l'appelé de l'op "entersub" s'il doit émettre
Diagnostique. Il est permis d'appliquer la fonction de contrôle dans des
situations, telles qu'un appel à un sous-programme différent ou à un appel de méthode.

nomgv peut ne pas être réellement un GV. Pour plus d'efficacité, perl peut passer un CV ou un autre SV
au lieu. Tout ce qui est passé peut être utilisé comme premier argument de "cv_name". Toi
peut forcer perl à passer un GV en incluant "CALL_CHECKER_REQUIRE_GV" dans le drapeaux.

Le paramètre actuel d'un CV particulier peut être récupéré par "cv_get_call_checker".

annuler cv_set_call_checker_flags(
CV *cv, Perl_call_checker ckfun, SV *ckobj,
drapeaux U32
)

LISTE DE LIENS
Étant donné la racine d'un optree, liez l'arbre dans l'ordre d'exécution en utilisant le "op_next"
pointeurs et renvoient la première opération exécutée. Si cela a déjà été fait, ce sera
ne sera pas refait, et "o->op_next" sera retourné. Si "o->op_next" n'est pas déjà
ensemble, o devrait être au moins un "UNOP".

OP* LISTE DE LIENS(OP *o)

nouveauCONSTSUB
Voir "newCONSTSUB_flags".

CV* newCONSTSUB(HV* cachette, const char* nom, SV* sv)

nouveauxCONSTSUB_flags
Crée un sous constant équivalent à Perl "sub FOO () { 123 }" qui est éligible
pour l'inlining au moment de la compilation.

Actuellement, la seule valeur utile pour "flags" est SVf_UTF8.

Le sous-programme nouvellement créé s'approprie une référence au passé en SV.

Passer NULL pour SV crée un sous-constant équivalent à "sub BAR () {}", qui
ne sera pas appelé s'il est utilisé comme destructeur, mais supprimera la surcharge d'un appel
sur "CHARGEMENT AUTOMATIQUE". (Ce formulaire, cependant, n'est pas éligible pour l'inlining au moment de la compilation.)

CV* newCONSTSUB_flags(HV* cachette, const char* nom,
STRLEN len, drapeaux U32, SV* sv)

newXS Utilisé par « xsubpp » pour connecter les XSUB en tant que sous-marins Perl. nom de fichier doit être statique
stockage, car il est utilisé directement comme CvFILE(), sans qu'une copie soit faite.

OpHAS_SIBLING
Renvoie true si o a un frère

booléen OpHAS_SIBLING(OP *o)

OpLASTSIB_set
Marque o comme n'ayant plus de frères et sœurs. Sur les builds "PERL_OP_PARENT", marque o comme
ayant le parent spécifié. Voir aussi "OpMORESIB_set" et "OpMAYBESIB_set". Pour un
interface de niveau supérieur, voir "op_sibling_splice".

annuler OpLASTSIB_set(OP *o, OP *parent)

OpMAYBESIB_set
Fait conditionnellement "OpMORESIB_set" ou "OpLASTSIB_set" selon si sib est
non nul. Pour une interface de niveau supérieur, voir "op_sibling_splice".

void OpMAYBESIB_set (OP *o, OP *sib, OP *parent)

OpMORESIB_set
Affecte au frère de o la valeur non nulle sib. Voir aussi "OpLASTSIB_set" et
"OpMAYBESIB_set". Pour une interface de niveau supérieur, voir "op_sibling_splice".

annuler OpMORESIB_set(OP *o, OP *sib)

OpSIBILAGE
Renvoie le frère de o, ou NULL s'il n'y a pas de frère

OP* OpSIBLING(OP *o)

op_append_elem
Ajouter un élément à la liste des opérations contenues directement dans une opération de type liste,
renvoyant la liste allongée. premier est l'op de type liste, et dernier est l'op de
ajouter à la liste. type d'option spécifie l'opcode prévu pour la liste. Si premier
n'est pas déjà une liste du bon type, elle sera mise à niveau en une seule. Si soit
premier or dernier est nul, l'autre est retourné inchangé.

OP * op_append_elem (optype I32, OP *premier, OP *dernier)

op_append_list
Concaténer les listes d'ops contenues directement dans deux ops de type liste,
renvoyant la liste combinée. premier et dernier sont les opérations de type liste à concaténer.
type d'option spécifie l'opcode prévu pour la liste. Si soit premier or dernier n'est pas
déjà une liste du bon type, elle sera mise à niveau en une seule. Si soit premier
or dernier est nul, l'autre est retourné inchangé.

OP * op_append_list(type d'op I32, OP *premier, OP *dernier)

OP_CLASS
Renvoie la classe de l'OP fourni : c'est-à-dire la structure *OP qu'il utilise.
Pour les opérations de base, cela obtient actuellement les informations de PL_opargs, qui ne
reflètent toujours avec précision le type utilisé. Pour les opérations personnalisées, le type est renvoyé à partir de
l'inscription, et il appartient au titulaire de s'assurer qu'elle est exacte. le
la valeur renvoyée sera l'une des constantes OA_* de op.h.

U32 OP_CLASS(OP *o)

op_contextualiser
Applique un contexte syntaxique à un arbre op représentant une expression. o est l'op
arbre, et aux contextes doit être "G_SCALAR", "G_ARRAY" ou "G_VOID" pour spécifier le
contexte à appliquer. L'arborescence op modifiée est renvoyée.

OP * op_contextualize(OP *o, contexte I32)

op_convert_list
Convertit o dans une liste op si ce n'en est pas déjà une, puis la convertit en
spécifié type, appelant sa fonction de vérification, allouant une cible s'il en a besoin,
et les constantes de pliage.

Une opération de type liste est généralement construite un enfant à la fois via "newLISTOP",
"op_prepend_elem" et "op_append_elem". Puis finalement il est passé à
"op_convert_list" pour en faire le bon type.

OP * op_convert_list(type I32, drapeaux I32, OP *o)

OP_DESC Renvoie une brève description de l'OP fourni.

caractère const * OP_DESC(OP *o)

op_free Libérez un op. N'utilisez ceci que lorsqu'un op n'est plus lié à aucun optree.

annuler op_free(OP *o)

op_linklist
Cette fonction est l'implémentation de la macro "LINKLIST". CA ne devrait pas être
appelé directement.

OP* op_linklist(OP *o)

op_lvalue
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Propager le contexte lvalue ("modifiable") à un op et à ses enfants. type
représente le type de contexte, à peu près basé sur le type d'opération qui ferait le
modifier, bien que "local()" soit représenté par OP_NULL, car il n'a pas de type op
qui lui est propre (il est signalé par un indicateur sur l'op lvalue).

Cette fonction détecte les choses qui ne peuvent pas être modifiées, comme "$x+1", et génère
erreurs pour eux. Par exemple, "$x+1 = 2" entraînerait son appel avec un op
de type OP_ADD et un argument "type" de OP_SASSIGN.

Il signale également les choses qui doivent se comporter spécialement dans un contexte lvalue, comme
"$$x = 5" qui peut avoir à vivifier une référence dans $x.

OP * op_lvalue(OP *o, type I32)

OP_NAME Renvoie le nom de l'OP fourni. Pour les opérations de base, cela recherche le nom du
op_type ; pour les opérations personnalisées à partir de op_ppaddr.

caractère const * OP_NAME(OP *o)

op_null Neutralise un op lorsqu'il n'est plus nécessaire, mais qu'il est toujours lié à d'autres
op.

annuler op_null(OP *o)

op_parent
Renvoie l'OP parent de o, s'il a un parent. Renvoie NULL sinon. Ce
La fonction n'est disponible que sur les perls construits avec "-DPERL_OP_PARENT".

OP* op_parent(OP *o)

op_prepend_elem
Ajoutez un élément à la liste des opérations contenues directement dans une opération de type liste,
renvoyant la liste allongée. premier est l'op à ajouter à la liste, et dernier
est l'op de type liste. type d'option spécifie l'opcode prévu pour la liste. Si dernier
n'est pas déjà une liste du bon type, elle sera mise à niveau en une seule. Si soit
premier or dernier est nul, l'autre est retourné inchangé.

OP * op_prepend_elem(type d'op I32, OP *premier, OP *dernier)

op_scope
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Enveloppe une arborescence d'opérations avec quelques opérations supplémentaires afin qu'au moment de l'exécution, une portée dynamique
sera créé. Les opérations d'origine s'exécutent dans la nouvelle portée dynamique, puis,
à condition qu'ils sortent normalement, la portée sera déroulée. Les opérations supplémentaires
utilisé pour créer et dérouler la portée dynamique sera normalement un "enter"/"leave"
paire, mais une opération "portée" peut être utilisée à la place si les opérations sont suffisamment simples pour ne pas
besoin de la structure de portée dynamique complète.

OP * op_scope(OP *o)

op_sibling_splice
Une fonction générale pour éditer la structure d'une chaîne existante de op_sibling
nœuds. Par analogie avec le niveau perl épissure() fonction, permet de supprimer
zéro ou plusieurs nœuds séquentiels, en les remplaçant par zéro ou plusieurs nœuds différents.
Effectue le ménage op_first/op_last nécessaire sur le nœud parent et
op_sibling manipulation sur les enfants. Le dernier nœud supprimé sera marqué comme
comme dernier nœud en mettant à jour le champ op_sibling/op_sibparent ou op_moresib comme
approprié.

Notez que op_next n'est pas manipulé et que les nœuds ne sont pas libérés ; C'est le
responsabilité de l'appelant. Il ne créera pas non plus une nouvelle op de liste pour un vide
liste etc.; utiliser des fonctions de niveau supérieur comme op_append_elem() pour ça.

parent est le nœud parent de la chaîne sœur. Il peut être passé à NULL si le
l'épissage n'affecte pas la première ou la dernière opération de la chaîne.

start est le nœud précédant le premier nœud à raccorder. Nœud(s) le suivant
sera supprimé et ops sera inséré après. S'il est NULL, le premier nœud
est supprimé et les nœuds sont insérés au début.

del_count est le nombre de nœuds à supprimer. Si zéro, aucun nœud n'est supprimé. Si -1
ou supérieur ou égal au nombre d'enfants restants, tous les enfants restants sont
supprimée.

insert est le premier d'une chaîne de nœuds à insérer à la place des nœuds. Si
NULL, aucun nœud n'est inséré.

La tête de la chaîne des opérations supprimées est renvoyée, ou NULL si aucune opération n'a été supprimée.

Par exemple :

action avant après retour
------ ----- ----- -------

PP
épissure(P, A, 2, XYZ) | | avant JC
ABCD AXYZD

PP
épissure(P, NULL, 1, XY) | | UNE
ABCD XYBCD

PP
épissure(P, NULL, 3, NULL) | | abc
ABC D

PP
épissure(P, B, 0, XY) | | NUL
ABCD ABXYCD

Pour la manipulation directe de niveau inférieur de "op_sibparent" et "op_moresib", voir
"OpMORESIB_set", "OpLASTSIB_set", "OpMAYBESIB_set".

OP* op_sibling_splice(OP *parent, OP *début,
int del_count, OP* insérer)

OP_TYPE_IS
Renvoie true si l'OP donné n'est pas un pointeur NULL et s'il est du type donné.

La négation de cette macro, "OP_TYPE_ISNT" est également disponible ainsi que
"OP_TYPE_IS_NN" et "OP_TYPE_ISNT_NN" qui éliminent la vérification du pointeur NULL.

bool OP_TYPE_IS(OP *o, type Optype)

OP_TYPE_IS_OR_WAS
Renvoie true si l'OP donné n'est pas un pointeur NULL et s'il est du type donné
ou utilisé avant d'être remplacé par un OP de type OP_NULL.

La négation de cette macro, "OP_TYPE_ISNT_AND_WASNT" est également disponible ainsi que
"OP_TYPE_IS_OR_WAS_NN" et "OP_TYPE_ISNT_AND_WASNT_NN" qui éliminent le NULL
vérification du pointeur.

bool OP_TYPE_IS_OR_WAS(OP *o, type Optype)

rv2cv_op_cv
Examine une opération, qui est censée identifier une sous-routine lors de l'exécution, et
tente de déterminer au moment de la compilation quel sous-programme il identifie. C'est
normalement utilisé lors de la compilation Perl pour déterminer si un prototype peut être
appliqué à un appel de fonction. CVOP est l'op considéré, normalement un "rv2cv"
op. Un pointeur vers le sous-programme identifié est renvoyé, s'il a pu être déterminé
statiquement, et un pointeur nul est renvoyé s'il n'a pas été possible de déterminer
statiquement.

Actuellement, le sous-programme peut être identifié statiquement si le RV que le "rv2cv"
doit opérer est fourni par une opération "gv" ou "const" appropriée. Une opération "gv" est
approprié si l'emplacement CV du GV est rempli. Une opération "const" convient si le
la valeur constante doit être un RV pointant vers un CV. Les détails de ce processus peuvent changer
dans les futures versions de Perl. Si l'op "rv2cv" a le drapeau "OPpENTERSUB_AMPER"
mis alors aucune tentative n'est faite pour identifier le sous-programme statiquement : ce drapeau est
utilisé pour supprimer la magie au moment de la compilation sur un appel de sous-programme, le forçant à utiliser
comportement d'exécution par défaut.

If drapeaux a le bit "RV2CVOPCV_MARK_EARLY" activé, puis la gestion d'un GV
référence est modifiée. Si un GV a été examiné et que son emplacement CV s'est avéré être
vide, alors l'op "gv" a le drapeau "OPpEARLY_CV" défini. Si l'op n'est pas
optimisé, et la fente CV est ensuite peuplée d'un sous-programme ayant un
prototype, ce drapeau déclenche éventuellement l'avertissement "appelé trop tôt pour vérifier
prototype".

If drapeaux a le bit "RV2CVOPCV_RETURN_NAME_GV" défini, alors au lieu de renvoyer un
pointeur vers le sous-programme il renvoie un pointeur vers le GV donnant le plus
nom approprié pour le sous-programme dans ce contexte. Normalement ce n'est que le
"CvGV" du sous-programme, mais pour un sous-programme anonyme ("CvANON") qui est
référencé via un GV ce sera le GV référençant. Le "GV*" résultant est
converti en "CV*" pour être renvoyé. Un pointeur nul est retourné comme d'habitude s'il n'y a pas
sous-programme déterminable statiquement.

CV * rv2cv_op_cv(OP *cvop, drapeaux U32)

PACK et Déballer

liste de colisage
Le moteur mettant en œuvre paquet() Fonction Perl.

liste de packs vide (SV *cat, const char *pat,
const char *patend, SV **beglist,
SV **liste finale)

déballerchaîne
Le moteur mettant en œuvre le déballer() Fonction Perl.

En utilisant le modèle pat..patend, cette fonction décompresse la chaîne s..strend dans un
nombre de SV mortels, qu'il pousse sur la pile d'arguments perl (@_) (vous
devra émettre un "PUTBACK" avant et "SPAGAIN" après l'appel à ce
une fonction). Il renvoie le nombre d'éléments poussés.

Les pointeurs strend et patend doivent pointer vers l'octet suivant le dernier
caractère de chaque chaîne.

Bien que cette fonction renvoie ses valeurs sur la pile d'arguments perl, elle ne
prendre tous les paramètres de cette pile (et donc en particulier il n'y a pas besoin de faire
un PUSHMARK avant de l'appeler, contrairement à "call_pv" par exemple).

I32 unpackstring(const char *pat,
caractère const *patend, caractère const *s,
caractère const *chaîne, indicateurs U32)

Tampon Date Structure

CvPADLISTE
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Les CV peuvent avoir CvPADLIST(cv) défini pour pointer vers une PADLIST. C'est le CV
bloc-notes, qui stocke les variables lexicales et les opcodes temporaires et par thread
valeurs.

À ces fins, les "formats" sont une sorte de CV ; eval""s sont aussi (sauf qu'ils ne sont pas
appelables à volonté et sont toujours rejetés après l'exécution de eval"".
Les fichiers requis sont simplement des evals sans aucune portée lexicale extérieure.

Les XSUB n'ont pas de CvPADLIST. dXSTARG récupère les valeurs de PL_curpad, mais c'est
vraiment le pavé des appelants (dont un emplacement est alloué par chaque entersub). Ne pas
obtenir ou définir CvPADLIST si un CV est un XSUB (tel que déterminé par "CvISXSUB()"), CvPADLIST
slot est réutilisé à des fins internes différentes dans les XSUB.

La PADLIST a un tableau C où les pads sont stockés.

La 0ème entrée de la PADLIST est une PADNAMELIST qui représente les "noms" ou
plutôt les "informations de type statique" pour les lexicaux. Les éléments individuels d'un
Les PADNAMELIST sont des PADNAME. Les futures refactorisations pourraient empêcher le PADNAMELIST de
étant stocké dans le tableau de PADLIST, ne vous y fiez donc pas. Voir "PadlistNAMES".

L'entrée CvDEPTH d'une PADLIST est un PAD (un AV) qui est le cadre de pile à
cette profondeur de récursivité dans le CV. Le 0ème slot d'une trame AV est un AV qui est
@_. Les autres entrées sont le stockage des variables et des cibles op.

Itérer sur PADNAMELIST itère sur tous les éléments de pad possibles. Emplacements pour coussinets
pour les cibles (SVs_PADTMP) et les GV finissent par avoir des "noms" &PL_padname_undef, tandis que
les emplacements pour les constantes ont des "noms" &PL_padname_const (voir pad_alloc()). Ce
&PL_padname_undef et &PL_padname_const sont utilisés est un détail d'implémentation
sous réserve de modifications. Pour les tester, utilisez "!PadnamePV(name)" et "PadnamePV(name)
&& !PadnameLEN(nom)", respectivement.

Seuls mes/nos emplacements variables obtiennent des noms valides. Le reste sont des cibles op/GV/constantes
qui sont statiquement alloués ou résolus au moment de la compilation. Ceux-ci n'ont pas
noms par lesquels ils peuvent être recherchés à partir du code Perl lors de l'exécution via eval"" le
façon dont mes/nos variables peuvent être. Puisqu'ils ne peuvent pas être recherchés par "nom" mais uniquement par
leur index alloué au moment de la compilation (qui est généralement dans PL_op->op_targ),
perdre un nom SV pour eux n'a pas de sens.

Les noms de pads dans PADNAMELIST ont leur PV contenant le nom de la variable.
Les champs COP_SEQ_RANGE_LOW et _HIGH forment une plage (low+1..high inclus) de
cop_seq numéros pour lesquels le nom est valide. Lors de la compilation, ces champs peuvent
maintenez la valeur spéciale PERL_PADSEQ_INTRO pour indiquer différentes étapes :

COP_SEQ_RANGE_LOW _HIGH
----------------- -----
PERL_PADSEQ_INTRO 0 variable pas encore introduite :
{ mon ($x
valid-seq# Variable PERL_PADSEQ_INTRO dans la portée :
{ mon ($x)
valid-seq# valid-seq# compilation de la portée terminée :
{ mon ($x) }

Pour les lexicaux typés, PadnameTYPE pointe vers la réserve de type. Pour "nos" lexicaux,
PadnameOURSTASH pointe vers le stash du global associé (afin que le doublon
"nos" déclarations dans le même paquet peuvent être détectées). PadnameGEN est parfois
utilisé pour stocker le numéro de génération lors de la compilation.

Si PadnameOUTER est défini sur le nom du pad, alors cet emplacement dans le cadre AV est un
Référence référencée à un lexique de "l'extérieur". De telles entrées sont parfois
qualifié de "faux". Dans ce cas, le nom n'utilise pas 'low' et 'high' pour
stocker une plage cop_seq, car elle est dans la portée tout au long. Au lieu de cela, les magasins "hauts"
quelques drapeaux contenant des informations sur le vrai lexique (est-il déclaré dans un anon, et
est-il capable d'être instancié plusieurs fois ?), et pour les faux ANON, "faible"
contient l'index dans le pad du parent où la valeur du lexique est stockée, pour
rendre le clonage plus rapide.

Si le 'nom' est '&', l'entrée correspondante dans le PAD est un CV représentant un
fermeture éventuelle.

Notez que les formats sont traités comme des sous-titres anonymes et sont clonés à chaque écriture
appelé (si nécessaire).

Le drapeau SVs_PADSTALE est effacé sur les lexicaux chaque fois que le ma() est exécuté, et
défini à la sortie de l'étendue. Cela permet à l'avertissement 'La variable $x n'est pas disponible' d'être
générées dans les évaluations, telles que

{ mon $x = 1 ; sous f { eval '$x'} } f();

Pour les variables d'état, SVs_PADSTALE est surchargé pour signifier "pas encore initialisé", mais cela
l'état interne est stocké dans une entrée de pad séparée.

PADLISTE * CvPADLISTE(CV *cv)

PadARRAY
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le tableau C des entrées de remplissage.

SV ** PadARRAY(pad pad)

PadlistARRAY
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le tableau C d'une liste de pads, contenant les pads. Indicez-le uniquement avec des nombres >=
1, car la 0ème entrée n'est pas garantie de rester utilisable.

PAD ** PadlistARRAY(PADLIST liste de pad)

PadlistMAX
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

L'index du dernier espace alloué dans la padlist. Notez que le dernier pad peut
être dans un créneau antérieur. Toutes les entrées qui le suivent seront NULL dans ce cas.

SSize_t PadlistMAX(PADLIST liste de pad)

PadlistNOMS
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Les noms associés aux entrées de pad.

PADNAMELIST * PadlistNAMES(PADLIST liste de pad)

Liste de padNAMESARRAY
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le tableau C des noms de pads.

PADNAME ** PadlistNAMESARRAY(PADLIST liste de pad)

Liste de padNAMESMAX
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

L'index du nom du dernier pad.

SSize_t PadlistNAMESMAX(PADLIST liste de pad)

PadlistREFCNT
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le nombre de références de la liste de pads. Actuellement, c'est toujours 1.

U32 PadlistREFCNT(PADLIST liste de pad)

PadMAX REMARQUE : cette fonction est expérimentale et peut changer ou être supprimée sans préavis.

L'index de la dernière entrée de pad.

STaille_t PadMAX (PAD pad)

Nom du padLEN
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

La longueur du nom.

STRLEN Nom du tamponLEN(NOM DU PAD pn)

Liste de noms de tamponsARRAY
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le tableau C des noms de pads.

PADNAME ** PadnamelistARRAY(PADNAMELIST pnl)

Liste de noms de tamponsMAX
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

L'index du nom du dernier pad.

SSize_t PadnamelistMAX(PADNAMELIST pnl)

PadnamelistREFCNT
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le nombre de références de la liste des noms de pad.

SSize_t PadnamelistREFCNT(PADNAMELIST pnl)

Liste de noms de tamponsREFCNT_dec
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Diminue le nombre de références de la liste des noms de pad.

annuler PadnamelistREFCNT_dec(PADNAMELIST pnl)

Nom du padPV
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le nom stocké dans la structure de nom de pad. Cela renvoie NULL pour un emplacement cible.

char * PadnamePV(PADNAME pn)

Nom du padREFCNT
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Le nombre de références du nom du pad.

SSize_t PadnameREFCNT(PADNAME pn)

Nom du blocREFCNT_dec
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Diminue le nombre de références du nom de pad.

void PadnameREFCNT_dec(PADNAME pn)

Nom du tamponSV
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Renvoie le nom du pad sous la forme d'un SV mortel.

SV * Nom du padSV(NOM DU PAD pn)

Nom du padUTF8
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Si PadnamePV est en UTF8. Actuellement, c'est toujours vrai.

bool PadnameUTF8 (PADNAME pn)

pad_add_name_pvs
Exactement comme "pad_add_name_pvn", mais prend une chaîne littérale au lieu d'un
paire chaîne/longueur.

PADOFFSET pad_add_name_pvs(const char *nom, drapeaux U32,
HV *typestash, HV *ourstash)

pad_findmy_pvs
Exactement comme "pad_findmy_pvn", mais prend une chaîne littérale au lieu d'un
paire chaîne/longueur.

PADOFFSET pad_findmy_pvs(car const *nom, drapeaux U32)

pad_new Crée une nouvelle liste de pads, mettant à jour les variables globales pour la compilation en cours
padlist pour pointer vers la nouvelle padlist. Les drapeaux suivants peuvent être associés par un OU :

padnew_CLONE ce pad est pour un CV cloné
padnew_SAVE enregistre les anciens globaux sur la pile de sauvegarde
padnew_SAVESUB enregistre également des éléments supplémentaires pour le début du sous-marin

PADLIST * pad_new (drapeaux int)

PL_comppad
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Lors de la compilation, cela pointe vers le tableau contenant les valeurs faisant partie du pad
pour le code en cours de compilation. (Au moment de l'exécution, un CV peut avoir plusieurs valeurs de ce type
tableaux ; au moment de la compilation, un seul est construit.) Au moment de l'exécution, cela pointe vers le
tableau contenant les valeurs actuellement pertinentes pour le pad pour le
code d'exécution.

PL_comppad_name
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Lors de la compilation, cela pointe vers le tableau contenant les noms faisant partie du pad
pour le code en cours de compilation.

PL_curpad
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Pointe directement sur le corps du tableau "PL_comppad". (C'est-à-dire que c'est
"PAD_ARRAY(PL_comppad)".)

Par interprète Variables

PL_modglobal
"PL_modglobal" est un interpréteur HV global à usage général à utiliser par les extensions
qui doivent conserver les informations par interprète. À la rigueur, il peut également
être utilisé comme table de symboles pour que les extensions partagent des données entre elles. C'est un
bonne idée d'utiliser des clés préfixées par le nom du package de l'extension qui possède le
revendre.

HV* PL_modglobal

PL_na Une variable de commodité qui est généralement utilisée avec "SvPV" quand on s'en fiche
sur la longueur de la chaîne. Il est généralement plus efficace soit de déclarer un
variable locale et l'utiliser à la place ou utiliser la macro "SvPV_nolen".

STRLEN PL_na

PL_opfreehook
Lorsqu'elle n'est pas "NULL", la fonction pointée par cette variable sera appelée à chaque fois qu'un
OP est libéré avec l'OP correspondant comme argument. Cela permet aux extensions de
libérer tout attribut supplémentaire qu'ils ont localement attaché à un OP. Il est également assuré
tirer d'abord pour le parent OP, puis pour ses enfants.

Lorsque vous remplacez cette variable, il est recommandé de stocker la
crochet éventuellement installé précédemment et que vous le rappeliez dans le vôtre.

Perl_ophook_t PL_opfreehook

PL_peepp
Pointeur vers l'optimiseur de judas par sous-programme. C'est une fonction qui obtient
appelée à la fin de la compilation d'un sous-programme Perl (ou de manière équivalente indépendante
morceau de code Perl) pour effectuer des corrections de certaines opérations et pour effectuer à petite échelle
optimisations. La fonction est appelée une fois pour chaque sous-programme compilé,
et est passé, comme seul paramètre, un pointeur vers l'op qui est le point d'entrée de
le sous-programme. Il modifie l'arborescence op en place.

L'optimiseur de judas ne doit jamais être complètement remplacé. Ajoutez plutôt du code à
en enveloppant l'optimiseur existant. La façon de faire de base peut être vue dans
"Compile pass 3 : optimisation du judas" dans perlguts. Si le nouveau code souhaite
opérer sur les opérations dans toute la structure de la sous-routine, plutôt que juste au sommet
niveau, il sera probablement plus pratique d'envelopper le crochet "PL_rpeepp".

peep_t PL_peepp

PL_rpeepp
Pointeur vers l'optimiseur de judas récursif. C'est une fonction qui s'appelle
à la fin de la compilation d'un sous-programme Perl (ou pièce indépendante équivalente
du code Perl) pour effectuer des corrections de certaines opérations et effectuer des opérations à petite échelle
optimisations. La fonction est appelée une fois pour chaque chaîne d'opérations liées par
leurs champs "op_next" ; il est appelé de manière récursive pour gérer chaque chaîne latérale. Il est
passé, comme seul paramètre, un pointeur vers l'op qui se trouve en tête de chaîne.
Il modifie l'arborescence op en place.

L'optimiseur de judas ne doit jamais être complètement remplacé. Ajoutez plutôt du code à
en enveloppant l'optimiseur existant. La façon de faire de base peut être vue dans
"Compile pass 3 : optimisation du judas" dans perlguts. Si le nouveau code souhaite
fonctionner uniquement sur les opérations au niveau supérieur d'un sous-programme, plutôt que tout au long du
structure, il est probablement plus pratique d'envelopper le crochet "PL_peepp".

peep_t PL_rpeepp

PL_sv_no
C'est le "faux" SV. Voir "PL_sv_yes". Faites toujours référence à cela en tant que &PL_sv_no.

SV PL_sv_no

PL_sv_undef
C'est le SV "undef". Faites toujours référence à cela en tant que &PL_sv_undef.

SV PL_sv_undef

PL_sv_oui
C'est le "vrai" SV. Voir "PL_sv_no". Faites toujours référence à cela en tant que &PL_sv_yes.

SV PL_sv_oui

REGEXP Les fonctions

Macro SvRX Convenience pour obtenir le REGEXP d'un SV. C'est à peu près équivalent
à l'extrait suivant :

si (SvMAGIQUE(sv))
mg_get(sv);
si (SvROK(sv))
sv = MUTABLE_SV(SvRV(sv));
si (SvTYPE(sv) == SVt_REGEXP)
retour (REGEXP*) sv ;

NULL sera retourné si une REGEXP* n'est pas trouvée.

REGEXP * SVRX(SV *sv)

SvRXOK Renvoie un booléen indiquant si le SV (ou celui auquel il fait référence) est un
EXP.REG.

Si vous voulez faire quelque chose avec le REGEXP * plus tard, utilisez SvRX à la place et vérifiez
NUL.

booléen SvRXOK(SV* sv)

Stack Manipulation Macros

dMARK Déclare une variable de marqueur de pile, "mark", pour la XSUB. Voir "MARQUE" et
"dORIGMARK".

dMARK ;

dORIGMARK
Enregistre la marque de pile d'origine pour la XSUB. Voir "ORIGMARK".

dORIGMARK ;

dSP Déclare une copie locale du pointeur de pile de perl pour la XSUB, disponible via le "SP"
macro. Voir "SP".

dSP ;

EXTEND Utilisé pour étendre la pile d'arguments pour les valeurs de retour d'une XSUB. Une fois utilisé,
garantit qu'il y a de la place pour au moins "nitems" à pousser sur la pile.

void EXTEND(SP, SSize_t éléments)

MARK Variable de marqueur de pile pour la XSUB. Voir "dMARK".

mPUSHi Pousser un entier sur la pile. La pile doit avoir de la place pour cet élément. Fait
n'utilisez pas "TARG". Voir aussi "PUSHi", "mXPUSHi" et "XPUSHi".

annuler mPUSHi(IV iv)

mPUSHn Poussez un double sur la pile. La pile doit avoir de la place pour cet élément. Fait
n'utilisez pas "TARG". Voir aussi "PUSHn", "mXPUSHn" et "XPUSHn".

annuler mPUSHn(NV nv)

mPUSHp Poussez une chaîne sur la pile. La pile doit avoir de la place pour cet élément. Le
"len" indique la longueur de la chaîne. N'utilise pas "TARG". Voir aussi "PUSHp",
"mXPUSHp" et "XPUSHp".

void mPUSHp(char* str, STRLEN len)

mPUSHs Poussez un SV sur la pile et tuez le SV. La pile doit avoir de la place pour
cet élément. N'utilise pas "TARG". Voir aussi "PUSH" et "mXPUSH".

annuler les mPUSH (SV* sv)

mPUSHu Poussez un entier non signé sur la pile. La pile doit avoir de la place pour cela
élément. N'utilise pas "TARG". Voir aussi "PUSHu", "mXPUSHu" et "XPUSHu".

annuler mPUSHu (UV uv)

mXPUSHi Pousser un entier sur la pile, en étendant la pile si nécessaire. N'utilise pas
« CIBLE ». Voir aussi « XPUSHi », « mPUSHi » et « PUSHi ».

annuler mXPUSHi(IV iv)

mXPUSHn Poussez un double sur la pile, prolongeant la pile si nécessaire. N'utilise pas
« CIBLE ». Voir aussi "XPUSHn", "mPUSHn" et "PUSHn".

annuler mXPUSHn(NV nv)

mXPUSHp Poussez une chaîne sur la pile, en étendant la pile si nécessaire. Le "len"
indique la longueur de la chaîne. N'utilise pas "TARG". Voir aussi "XPUSHp",
"mPUSHp" et "PUSHp".

void mXPUSHp(char* str, STRLEN len)

mXPUSHs Poussez un SV sur la pile, prolongeant la pile si nécessaire et mortalise le SV.
N'utilise pas "TARG". Voir aussi "XPUSH" et "mPUSH".

annuler les mXPUSH (SV* sv)

mXPUSHu Poussez un entier non signé sur la pile, en étendant la pile si nécessaire. Fait
n'utilisez pas "TARG". Voir aussi "XPUSHu", "mPUSHu" et "PUSHu".

annuler mXPUSHu (UV uv)

MARQUE D'ORIGINE
La marque de pile d'origine pour le XSUB. Voir "dORIGMARK".

POPi Extrait un entier de la pile.

IV POPi

POPl sort longtemps de la pile.

longue POPl

POPn Sort un double de la pile.

NV POPn

POPp Extrait une chaîne de la pile.

caractère* POPp

POPpbytex
Extrait une chaîne de la pile qui doit être composée d'octets, c'est-à-dire de caractères < 256.

caractère* POPpbytex

POPpx Extrait une chaîne de la pile. Identique à POPp. Il y a deux noms pour
raisons historiques.

caractère* POPpx

POPs Éjecte un SV de la pile.

SV* POP

PUSHi Pousser un entier sur la pile. La pile doit avoir de la place pour cet élément.
Manipule la magie 'set'. Utilise "TARG", donc "dTARGET" ou "dXSTARG" doit être appelé pour
le déclarer. N'appelez pas plusieurs macros orientées "TARG" pour renvoyer des listes à partir de
XSUB - voir "mPUSHi" à la place. Voir aussi "XPUSHi" et "mXPUSHi".

annuler PUSHi(IV iv)

POUSSOIR
Parenthèse ouvrante pour les arguments d'un rappel. Voir "PUTBACK" et perlcall.

annuler PUSHMARK(SP)

PUSHmortel
Poussez un nouveau SV mortel sur la pile. La pile doit avoir de la place pour cet élément.
N'utilise pas "TARG". Voir aussi "PUSH", "XPUSHmortal" et "XPUSH".

annuler PUSHmortal()

PUSHn Poussez un double sur la pile. La pile doit avoir de la place pour cet élément. Poignées
'set' magique. Utilise "TARG", donc "dTARGET" ou "dXSTARG" doit être appelé pour déclarer
ce. N'appelez pas plusieurs macros orientées "TARG" pour renvoyer des listes à partir de XSUB - voir
"mPUSHn" à la place. Voir aussi "XPUSHn" et "mXPUSHn".

annuler PUSHn(NV nv)

PUSHp Pousser une chaîne sur la pile. La pile doit avoir de la place pour cet élément. Le
"len" indique la longueur de la chaîne. Manipule la magie 'set'. Utilise "TARG", donc
"dTARGET" ou "dXSTARG" doit être appelé pour le déclarer. N'appelez pas plusieurs
Macros orientées "TARG" pour renvoyer des listes à partir de XSUB - voir "mPUSHp" à la place. Voir
également "XPUSHp" et "mXPUSHp".

void PUSHp(char* str, STRLEN len)

PUSH Poussez un SV sur la pile. La pile doit avoir de la place pour cet élément. Ne fait pas
gérer la magie 'set'. N'utilise pas "TARG". Voir aussi "PUSHmortal", "XPUSHs" et
"XPUSHmortel".

annuler les PUSH (SV* sv)

PUSHu Pousser un entier non signé sur la pile. La pile doit avoir de la place pour cela
élément. Manipule la magie 'set'. Utilise "TARG", donc "dTARGET" ou "dXSTARG" doit être
appelé pour le déclarer. N'appelez pas plusieurs macros orientées "TARG" pour renvoyer des listes
de XSUB - voir "mPUSHu" à la place. Voir aussi "XPUSHu" et "mXPUSHu".

vide PUSHu (UV uv)

PUTBACK Crochet fermant pour les arguments XSUB. Ceci est généralement géré par "xsubpp". Voir
"PUSHMARK" et perlcall pour d'autres usages.

RETOUR ;

Pointeur de pile SP. Ceci est généralement géré par "xsubpp". Voir "dSP" et "SPAGAIN".

SPAGAIN Récupérer le pointeur de pile. Utilisé après un rappel. Voir perlcall.

ESPAGNE ;

XPUSHi Pousser un entier sur la pile, en étendant la pile si nécessaire. Poignées 'ensemble'
la magie. Utilise "TARG", donc "dTARGET" ou "dXSTARG" doit être appelé pour le déclarer. Faire
ne pas appeler plusieurs macros orientées "TARG" pour renvoyer des listes à partir de XSUB - voir
"mXPUSHi" à la place. Voir aussi "PUSHi" et "mPUSHi".

annuler XPUSHi(IV iv)

XPUSHmortel
Poussez un nouveau SV mortel sur la pile, en étendant la pile si nécessaire. Ne fait pas
utilisez "TARG". Voir aussi "XPUSH", "PUSHmortal" et "PUSH".

annuler XPUSHmortal()

XPUSHn Poussez un double sur la pile, en étendant la pile si nécessaire. Poignées 'ensemble'
la magie. Utilise "TARG", donc "dTARGET" ou "dXSTARG" doit être appelé pour le déclarer. Faire
ne pas appeler plusieurs macros orientées "TARG" pour renvoyer des listes à partir de XSUB - voir
"mXPUSHn" à la place. Voir aussi "PUSHn" et "mPUSHn".

annuler XPUSHn(NV nv)

XPUSHp Poussez une chaîne sur la pile, en étendant la pile si nécessaire. Le "len"
indique la longueur de la chaîne. Manipule la magie 'set'. Utilise "TARG", donc
"dTARGET" ou "dXSTARG" doit être appelé pour le déclarer. N'appelez pas plusieurs
Macros orientées "TARG" pour renvoyer des listes à partir de XSUB - voir "mXPUSHp" à la place. Voir
également "PUSHp" et "mPUSHp".

void XPUSHp(char* str, STRLEN len)

XPUSH Poussez un SV sur la pile, en étendant la pile si nécessaire. Ne gère pas
'set' magique. N'utilise pas "TARG". Voir aussi "XPUSHmortal", "PUSH" et
"PUSHmortel".

annuler les XPUSH (SV* sv)

XPUSHu Poussez un entier non signé sur la pile, en étendant la pile si nécessaire.
Manipule la magie 'set'. Utilise "TARG", donc "dTARGET" ou "dXSTARG" doit être appelé pour
le déclarer. N'appelez pas plusieurs macros orientées "TARG" pour renvoyer des listes à partir de
XSUB - voir "mXPUSHu" à la place. Voir aussi "PUSHu" et "mPUSHu".

annuler XPUSHu (UV uv)

XSRETOUR
Retour de XSUB, indiquant le nombre d'éléments sur la pile. C'est généralement
géré par "xsubpp".

void XSRETURN(int éléments)

XSRETURN_EMPTY
Renvoie immédiatement une liste vide à partir d'une XSUB.

XSRETURN_EMPTY ;

XSRETURN_IV
Renvoie immédiatement un entier à partir d'une XSUB. Utilise "XST_mIV".

annuler XSRETURN_IV(IV iv)

XSRETURN_NO
Renvoie immédiatement &PL_sv_no depuis une XSUB. Utilise "XST_mNO".

XSRETURN_NO ;

XSRETURN_NV
Renvoie immédiatement un double d'un XSUB. Utilise "XST_mNV".

annuler XSRETURN_NV(NV nv)

XSRETURN_PV
Renvoie immédiatement une copie d'une chaîne à partir d'une XSUB. Utilise "XST_mPV".

annuler XSRETURN_PV(char* str)

XSRETURN_UNDEF
Renvoie immédiatement &PL_sv_undef à partir d'une XSUB. Utilise "XST_mUNDEF".

XSRETURN_UNDEF ;

XSRETURN_UV
Renvoie immédiatement un entier à partir d'une XSUB. Utilise "XST_mUV".

annuler XSRETURN_UV(IV uv)

XSRETURN_OUI
Renvoie immédiatement &PL_sv_yes depuis une XSUB. Utilise "XST_mYES".

XSRETURN_OUI ;

XST_mIV Place un entier dans la position spécifiée "pos" sur la pile. La valeur est
stocké dans un nouveau SV mortel.

void XST_mIV(int pos, IV iv)

XST_mNO Placer &PL_sv_no dans la position spécifiée "pos" sur la pile.

annuler XST_mNO(int pos)

XST_mNV Place un double dans la position spécifiée "pos" sur la pile. La valeur est
stocké dans un nouveau SV mortel.

void XST_mNV(int pos, NV nv)

XST_mPV Place une copie d'une chaîne dans la position spécifiée "pos" sur la pile. Le
la valeur est stockée dans un nouveau SV mortel.

void XST_mPV(int pos, char* str)

XST_mUNDEF
Placez &PL_sv_undef dans la position spécifiée "pos" sur la pile.

annuler XST_mUNDEF(int pos)

XST_mOUI
Placez &PL_sv_yes dans la position spécifiée "pos" sur la pile.

annuler XST_mYES (int pos)

SV Drapeaux

svtype Une énumération de drapeaux pour les types Perl. Ceux-ci se trouvent dans le fichier sv.h dans le "svtype"
énumération. Testez ces drapeaux avec la macro "SvTYPE".

Les genres sont :

SVt_NULL
SVt_IV
SVt_NV
SVt_RV
SVt_PV
SVt_PVIV
SVt_PVNV
SVt_PVMG
SVt_INVLISTE
SVt_REGEXP
SVt_PVGV
SVt_PVLV
SVt_PVAV
SVt_PVHV
SVt_PVCV
SVt_PVFM
SVt_PVIO

Ceux-ci sont plus facilement expliqués de bas en haut.

SVt_PVIO est pour les objets d'E/S, SVt_PVFM pour les formats, SVt_PVCV pour les sous-programmes,
SVt_PVHV pour les hachages et SVt_PVAV pour les tableaux.

Tous les autres sont des types scalaires, c'est-à-dire des choses qui peuvent être liées à un "$"
variable. Pour ceux-ci, les types internes sont pour la plupart orthogonaux aux types dans le
Langage Perle.

Par conséquent, vérifier "SvTYPE(sv) < SVt_PVAV" est le meilleur moyen de voir si quelque chose
est un scalaire.

SVt_PVGV représente un typeglob. Si !SvFAKE(sv), alors c'est un vrai, incoercible
typeglob. Si SvFAKE(sv), alors c'est un scalaire auquel un typeglob a été
attribué. Lui assigner à nouveau l'empêchera d'être un typeglob. SVt_PVLV
représente un scalaire qui délègue à un autre scalaire dans les coulisses. Il est
utilisé, par exemple, pour la valeur de retour de "substr" et pour les éléments liés de hachage et de tableau.
Il peut contenir n'importe quelle valeur scalaire, y compris un typeglob. SVt_REGEXP est pour régulier
expressions. SVt_INVLIST est réservé à l'usage interne du noyau Perl.

SVt_PVMG représente un scalaire "normal" (pas un typeglob, une expression régulière ou
déléguer). Puisque la plupart des scalaires n'ont pas besoin de tous les champs internes d'un PVMG, nous
économisez de la mémoire en allouant des structures plus petites lorsque cela est possible. Tous les autres types sont
juste des formes plus simples de SVt_PVMG, avec moins de champs internes.
SVt_NULL ne peut contenir qu'undef. SVt_IV peut contenir un def, un entier ou une référence.
(SVt_RV est un alias pour SVt_IV, qui existe pour la rétrocompatibilité.) SVt_NV
peut contenir n'importe lequel de ceux-ci ou un double. SVt_PV ne peut contenir qu'undef ou une chaîne.
SVt_PVIV est un sur-ensemble de SVt_PV et SVt_IV. SVt_PVNV est similaire. SVt_PVMG peut
tenir tout ce que SVt_PVNV peut tenir, mais il peut, mais n'est pas obligé, être béni ou
magique.

SVt_INVLISTE
Indicateur de type pour les scalaires. Voir "svtype".

SVt_IV Indicateur de type pour les scalaires. Voir "svtype".

SVt_NULL
Indicateur de type pour les scalaires. Voir "svtype".

SVt_NV Indicateur de type pour les scalaires. Voir "svtype".

SVt_PV Indicateur de type pour les scalaires. Voir "svtype".

SVt_PVAV
Indicateur de type pour les tableaux. Voir "svtype".

SVt_PVCV
Indicateur de type pour les sous-programmes. Voir "svtype".

SVt_PVFM
Indicateur de type pour les formats. Voir "svtype".

SVt_PVGV
Indicateur de type pour les typeglobs. Voir "svtype".

SVt_PVHV
Indicateur de type pour les hachages. Voir "svtype".

SVt_PVIO
Indicateur de type pour les objets d'E/S. Voir "svtype".

SVt_PVIV
Indicateur de type pour les scalaires. Voir "svtype".

SVt_PVLV
Indicateur de type pour les scalaires. Voir "svtype".

SVt_PVMG
Indicateur de type pour les scalaires. Voir "svtype".

SVt_PVNV
Indicateur de type pour les scalaires. Voir "svtype".

SVt_REGEXP
Indicateur de type pour les expressions régulières. Voir "svtype".

SV Manipulation Les fonctions

boolSV Renvoie un vrai SV si "b" est une valeur vraie, ou un faux SV si "b" est 0.

Voir aussi "PL_sv_yes" et "PL_sv_no".

SV * boolSV(bool b)

croak_xs_usage
Une variante spécialisée de "croak()" pour émettre le message d'utilisation pour xsubs

croak_xs_usage(cv, "eee_yow");

calcule le nom du package et le nom de la sous-routine à partir de "cv", puis appelle
"crever()". Donc si "cv" est &ouch::awk, il s'appellera "croak" comme suit :

Perl_croak(aTHX_ "Utilisation : %"SVf"::%"SVf"(%s)", "aïe" "awk",
"eee_yow");

void croak_xs_usage(const CV *const cv,
caractère const * paramètres const)

get_sv Renvoie la SV du scalaire Perl spécifié. "flags" sont passés à "gv_fetchpv".
Si "GV_ADD" est défini et que la variable Perl n'existe pas, elle sera créée.
Si « drapeaux » est égal à zéro et que la variable n'existe pas, NULL est renvoyé.

REMARQUE : la forme perl_ de cette fonction est dépréciée.

SV* get_sv(const char *nom, drapeaux I32)

nouveauRV_inc
Crée un wrapper RV pour un SV. Le nombre de références pour le SV d'origine est
incrémenté.

SV* nouveauRV_inc(SV* sv)

nouveauSVpadname
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Crée un nouveau SV contenant le nom du pad.

SV* nouveauSVpadname(PADNAME *pn)

nouveauSVpvn_utf8
Crée un nouveau SV et copie une chaîne (qui peut contenir des caractères "NUL" ("\0")
dans ça. Si utf8 est vrai, appelle "SvUTF8_on" sur le nouveau SV. Mis en œuvre comme un
wrapper autour de "newSVpvn_flags".

SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len,
U32 (utf8)

SvCUR Renvoie la longueur de la chaîne qui se trouve dans le SV. Voir "SvLEN".

STRLEN SvCUR(SV* sv)

SvCUR_set
Définissez la longueur actuelle de la chaîne qui se trouve dans le SV. Voir "SvCUR" et
"SvIV_set".

void SvCUR_set(SV* sv, STRLEN len)

SvEND Renvoie un pointeur à l'endroit juste après le dernier caractère de la chaîne qui est
dans le SV, où il y a généralement un caractère "NUL" à la fin (même si Perl
les scalaires ne l'exigent pas strictement). Voir "SvCUR". Accédez au personnage comme
*(SvEND(sv)).

Attention : Si "SvCUR" est égal à "SvLEN", alors "SvEND" pointe vers non alloué
mémoire.

car* SvEND(SV* sv)

SvGAMAGIQUE
Renvoie vrai si le SV a obtenu de la magie ou une surcharge. Si l'un ou l'autre est vrai, alors le
scalaire est une donnée active et a le potentiel de renvoyer une nouvelle valeur à chaque fois qu'il
est accessible. Par conséquent, vous devez faire attention à ne le lire qu'une seule fois par utilisateur logique
opération et travailler avec cette valeur renvoyée. Si ni l'un ni l'autre n'est vrai, alors le scalaire
la valeur ne peut pas changer à moins d'être écrite.

U32 SvGAMAGIQUE(SV* sv)

SvGROW Développe le tampon de caractères dans le SV afin qu'il ait de la place pour le
nombre d'octets (n'oubliez pas de réserver de l'espace pour un caractère "NUL" supplémentaire à la fin).
Appelle "sv_grow" pour effectuer l'expansion si nécessaire. Renvoie un pointeur vers le
tampon de caractères. SV doit être de type >= SVt_PV. Une alternative est d'appeler
"sv_grow" si vous n'êtes pas sûr du type de SV.

char * SvGROW(SV* sv, STRLEN len)

SvIOK Renvoie une valeur U32 indiquant si la SV contient un entier.

U32 SVIOK(SV* sv)

SvIOKp Renvoie une valeur U32 indiquant si la SV contient un entier. Vérifie la
Privé paramètre. Utilisez "SvIOK" à la place.

U32 SvIOKp(SV* sv)

SvIOK_notUV
Renvoie un booléen indiquant si la SV contient un entier signé.

booléen SvIOK_notUV(SV* sv)

SvIOK_off
Annule l'état IV d'un SV.

annuler SvIOK_off(SV* sv)

SvIOK_on
Indique à un SV qu'il s'agit d'un nombre entier.

annuler SvIOK_on(SV* sv)

SvIOK_uniquement
Indique à un SV qu'il s'agit d'un entier et désactive tous les autres bits OK.

annuler SvIOK_only(SV* sv)

SvIOK_only_UV
Indique à un SV qu'il s'agit d'un entier non signé et désactive tous les autres bits OK.

annuler SvIOK_only_UV(SV* sv)

SvIOK_UV
Renvoie un booléen indiquant si la SV contient un entier qui doit être
interprété comme non signé. Un entier non négatif dont la valeur est comprise dans la plage
d'un IV et d'un UV peuvent être signalés comme SvUOK ou SVIOK.

booléen SvIOK_UV(SV* sv)

SvIsCOW Renvoie une valeur U32 indiquant si le SV est Copy-On-Write (soit hachage partagé
scalaires clés ou scalaires complets de copie sur écriture si 5.9.0 est configuré pour COW).

U32 SvIsCOW(SV* sv)

SvIsCOW_shared_hash
Renvoie un booléen indiquant si le SV est une clé de hachage partagée Copy-On-Write
scalaire.

booléen SvIsCOW_shared_hash(SV* sv)

SvIV Contraint le SV donné à un entier et le renvoie. Voir "SvIVx" pour une version
ce qui garantit de n'évaluer sv qu'une seule fois.

IV SvIV(SV* sv)

SvIVX Renvoie la valeur brute dans l'emplacement IV du SV, sans vérification ni conversion. Seulement
à utiliser lorsque vous êtes sûr que SvIOK est vrai. Voir aussi "SvIV()".

IV SvIVX(SV* sv)

SvIVx Contraint le SV donné à un entier et le renvoie. Garanties pour évaluer "sv"
juste une fois. N'utilisez ceci que si "sv" est une expression avec des effets secondaires, sinon
utilisez le "SvIV" plus efficace.

IV SvIVx(SV* sv)

SvIV_nomg
Comme "SvIV" mais ne traite pas la magie.

IV SvIV_nomg(SV* sv)

SvIV_set
Définissez la valeur du pointeur IV dans sv sur val. Il est possible d'effectuer le même
fonction de cette macro avec une affectation de lvalue à "SvIVX". Avec les futurs Perls,
cependant, il sera plus efficace d'utiliser "SvIV_set" au lieu de la lvalue
affectation à "SvIVX".

void SvIV_set(SV* sv, IV val)

SvLEN Renvoie la taille du tampon de chaîne dans le SV, à l'exclusion de toute partie
attribuable à "SvOOK". Voir "SvCUR".

STRLEN SvLEN(SV* sv)

SvLEN_set
Définissez la longueur réelle de la chaîne qui se trouve dans le SV. Voir "SvIV_set".

void SvLEN_set(SV* sv, STRLEN len)

SvMAGIC_set
Définissez la valeur du pointeur MAGIC dans sv sur val. Voir "SvIV_set".

annuler SvMAGIC_set(SV* sv, MAGIC* val)

SvNIOK Renvoie une valeur U32 indiquant si le SV contient un nombre, un entier ou
double.

U32 SVNIOK(SV* SV)

SvNIOKp Renvoie une valeur U32 indiquant si le SV contient un nombre, un entier ou
double. Vérifie la Privé paramètre. Utilisez "SvNIOK" à la place.

U32 SvNIOKp(SV* sv)

SvNIOK_off
Annule l'état NV/IV d'un SV.

annuler SvNIOK_off(SV* sv)

SvNOK Renvoie une valeur U32 indiquant si le SV contient un double.

U32 SvNOK(SV* sv)

SvNOKp Renvoie une valeur U32 indiquant si le SV contient un double. Vérifie la
Privé paramètre. Utilisez "SvNOK" à la place.

U32 SvNOKp(SV* sv)

SvNOK_off
Annule l'état NV d'un SV.

annuler SvNOK_off(SV* sv)

SvNOK_on
Indique à un SV qu'il s'agit d'un double.

annuler SvNOK_on(SV* sv)

SvNOK_uniquement
Indique à un SV qu'il s'agit d'un double et désactive tous les autres bits OK.

annuler SvNOK_only(SV* sv)

SvNV Contraindre le SV donné à un double et le retourner. Voir "SvNVx" pour une version qui
garantit d'évaluer sv une seule fois.

NV SvNV(SV* sv)

SvNVX Renvoie la valeur brute dans l'emplacement NV du SV, sans vérification ni conversion. Seulement
à utiliser lorsque vous êtes sûr que SvNOK est vrai. Voir aussi "SvNV()".

NV SvNVX(SV* sv)

SvNVx Contraint le SV donné à un double et le renvoie. Garanties d'évaluer "sv" uniquement
une fois que. N'utilisez ceci que si "sv" est une expression avec des effets secondaires, sinon utilisez le
"SvNV" plus efficace.

NV SvNVx(SV* sv)

SvNV_nomg
Comme "SvNV" mais ne traite pas la magie.

NV SvNV_nomg(SV* sv)

SvNV_set
Définissez la valeur du pointeur NV dans sv sur val. Voir "SvIV_set".

annuler SvNV_set(SV* sv, NV val)

SvOK Renvoie une valeur U32 indiquant si la valeur est définie. C'est seulement
significatif pour les scalaires.

U32 SVOK(SV* SV)

SvOOK Renvoie un U32 indiquant si le pointeur vers le tampon de chaîne est décalé. Cette
hack est utilisé en interne pour accélérer la suppression des caractères depuis le début d'un
SvPV. Lorsque SvOOK est vrai, le début du tampon de chaîne alloué est
en fait "SvOOK_offset()" octets avant SvPVX. Ce décalage était stocké dans
SvIVX, mais est maintenant stocké dans la pièce de rechange du tampon.

U32 SVOOK(SV* SV)

SvOOK_offset
Lit dans len le décalage de SvPVX vers le vrai début de l'alloué
tampon, qui sera différent de zéro si "sv_chop" a été utilisé pour supprimer efficacement
caractères depuis le début du tampon. Implémenté comme une macro, qui prend le
adresse de len, qui doit être de type "STRLEN". Évalue sv plus d'une fois.
Ensembles len à 0 si "SvOOK(sv)" est faux.

void SvOOK_offset(NN SV*sv, STRLEN len)

SvPOK Renvoie une valeur U32 indiquant si le SV contient une chaîne de caractères.

U32 SvPOK(SV* sv)

SvPOKp Renvoie une valeur U32 indiquant si le SV contient une chaîne de caractères. Chèques
le Privé paramètre. Utilisez "SvPOK" à la place.

U32 SvPOKp(SV* sv)

SvPOK_off
Désactive l'état PV d'un SV.

annuler SvPOK_off(SV* sv)

SvPOK_on
Indique à un SV qu'il s'agit d'une chaîne.

annuler SvPOK_on(SV* sv)

SvPOK_uniquement
Indique à un SV qu'il s'agit d'une chaîne et désactive tous les autres bits OK. Tournera également
désactiver le statut UTF-8.

annuler SvPOK_only(SV* sv)

SvPOK_only_UTF8
Indique à un SV qu'il s'agit d'une chaîne et désactive tous les autres bits OK, et laisse le
Statut UTF-8 tel qu'il était.

annuler SvPOK_only_UTF8(SV* sv)

SvPV Renvoie un pointeur vers la chaîne dans la SV, ou une forme sous forme de chaîne de la SV si la
SV ne contient pas de chaîne. Le SV peut mettre en cache la version stringifiée devenant
"SvPOK". Les poignées 'get' la magie. La variable "len" sera définie sur la longueur de
la chaîne (c'est une macro, donc n'utilisez pas &len). Voir aussi "SvPVx" pour une version
ce qui garantit de n'évaluer sv qu'une seule fois.

Notez qu'il n'y a aucune garantie que la valeur de retour de "SvPV()" soit égale à
"SvPVX(sv)", ou que "SvPVX(sv)" contient des données valides, ou que des appels successifs à
"SvPV(sv)" renverra la même valeur de pointeur à chaque fois. Cela est dû à la manière
que des choses comme la surcharge et la copie sur écriture sont gérées. Dans ces cas, le
la valeur de retour peut pointer vers un tampon temporaire ou similaire. Si vous avez absolument besoin
que le champ SvPVX soit valide (par exemple, si vous avez l'intention d'y écrire), alors consultez
"SvPV_force".

car* SvPV(SV* sv, STRLEN len)

SvPVoctet
Comme "SvPV", mais convertit d'abord sv en représentation d'octet si nécessaire.

char* SvPVbyte(SV* sv, STRLEN len)

SvPVbytex
Comme "SvPV", mais convertit d'abord sv en représentation d'octet si nécessaire.
Garantit de n'évaluer sv qu'une seule fois ; utilisez le "SvPVbyte" plus efficace sinon.

char* SvPVbytex(SV* sv, STRLEN len)

SvPVbytex_force
Comme "SvPV_force", mais convertit d'abord sv en représentation d'octet si nécessaire.
Garantit de n'évaluer sv qu'une seule fois ; utilisez le plus efficace "SvPVbyte_force"
autrement.

char* SvPVbytex_force(SV* sv, STRLEN len)

SvPVbyte_force
Comme "SvPV_force", mais convertit d'abord sv en représentation d'octet si nécessaire.

char* SvPVbyte_force(SV* sv, STRLEN len)

SvPVbyte_nolen
Comme "SvPV_nolen", mais convertit d'abord sv en représentation d'octet si nécessaire.

char* SvPVbyte_nolen(SV* sv)

SvPVutf8
Comme "SvPV", mais convertit d'abord sv en utf8 si nécessaire.

char* SvPVutf8(SV* sv, STRLEN len)

SvPVutf8x
Comme "SvPV", mais convertit d'abord sv en utf8 si nécessaire. Des garanties à évaluer
sv une seule fois ; utilisez le "SvPVutf8" plus efficace sinon.

char* SvPVutf8x(SV* sv, STRLEN len)

SvPVutf8x_force
Comme "SvPV_force", mais convertit d'abord sv en utf8 si nécessaire. Garanties à
évaluer sv une seule fois ; utilisez le "SvPVutf8_force" plus efficace sinon.

char* SvPVutf8x_force(SV* sv, STRLEN len)

SvPVutf8_force
Comme "SvPV_force", mais convertit d'abord sv en utf8 si nécessaire.

char* SvPVutf8_force(SV* sv, STRLEN len)

SvPVutf8_nolen
Comme "SvPV_nolen", mais convertit d'abord sv en utf8 si nécessaire.

char* SvPVutf8_nolen(SV* sv)

SvPVX Renvoie un pointeur vers la chaîne physique dans le SV. Le SV doit contenir une chaîne.
Avant 5.9.3, il n'est pas sûr d'exécuter cette macro à moins que le type de SV >=
SVt_PV.

Ceci est également utilisé pour stocker le nom d'un sous-programme chargé automatiquement dans un XS AUTOLOAD
routine. Voir "Chargement automatique avec XSUB" dans perlguts.

car* SvPVX(SV* sv)

SvPVx Une version de "SvPV" qui garantit d'évaluer "sv" une seule fois. N'utilisez ceci que si
"sv" est une expression avec des effets secondaires, sinon utilisez le plus efficace "SvPV".

car* SvPVx(SV* sv, STRLEN len)

SvPV_force
Comme "SvPV" mais forcera le SV à contenir une chaîne ("SvPOK"), et seulement un
chaîne ("SvPOK_only"), par crochet ou par escroc. Vous avez besoin de force si vous voulez
mettre à jour le "SvPVX" directement. Les processus deviennent magiques.

Notez que la contrainte d'un scalaire arbitraire dans un PV simple supprimera potentiellement
données utiles de celui-ci. Par exemple, si le SV était "SvROK", alors le référent sera
avoir son décompte de référence décrémenté, et le SV lui-même peut être converti en un
Scalaire "SvPOK" avec un tampon de chaîne contenant une valeur telle que "TABLEAU(0x1234)".

char* SvPV_force(SV* sv, STRLEN len)

SvPV_force_nomg
Comme "SvPV_force", mais le processus n'obtient pas de magie.

char* SvPV_force_nomg(SV* sv, STRLEN len)

SvPV_nolen
Comme "SvPV" mais ne définit pas de variable de longueur.

char* SvPV_nolen(SV* sv)

SvPV_nomg
Comme "SvPV" mais ne traite pas la magie.

char* SvPV_nomg(SV* sv, STRLEN len)

SvPV_nomg_nolen
Comme "SvPV_nolen" mais ne traite pas la magie.

char* SvPV_nomg_nolen(SV* sv)

SvPV_set
Ce n'est probablement pas ce que vous voulez utiliser, vous vouliez probablement "sv_usepvn_flags"
ou "sv_setpvn" ou "sv_setpvs".

Définissez la valeur du pointeur PV dans "sv" sur le Perl alloué "NUL" terminé
chaîne "val". Voir aussi "SvIV_set".

N'oubliez pas de libérer le tampon PV précédent. Il y a beaucoup de choses à vérifier. Il faut se méfier
que le pointeur existant peut être impliqué dans la copie sur écriture ou d'autres méfaits, donc
faire "SvOOK_off(sv)" et utiliser "sv_force_normal" ou "SvPV_force" (ou vérifier le SvIsCOW
flag) d'abord pour vous assurer que cette modification est sûre. Enfin, si ce n'est pas un
COW, appelez "SvPV_free" pour libérer le tampon PV précédent.

void SvPV_set(SV* sv, char* val)

SvREFCNT
Renvoie la valeur du compteur de références de l'objet.

U32 SvREFCNT(SV* sv)

SvREFCNT_dec
Décrémente le décompte de référence du SV donné. sv peut être NULL.

annuler SvREFCNT_dec(SV* sv)

SvREFCNT_dec_NN
Identique à SvREFCNT_dec, mais ne peut être utilisé que si vous savez sv est non nulle. Depuis que nous
n'avez pas à vérifier le NULLness, c'est plus rapide et plus petit.

annuler SvREFCNT_dec_NN(SV* sv)

SvREFCNT_inc
Incrémente le nombre de références du SV donné, renvoyant le SV.

Toutes les macros SvREFCNT_inc* suivantes sont des versions optimisées de SvREFCNT_inc,
et peut être remplacé par SvREFCNT_inc.

SV* SvREFCNT_inc(SV* sv)

SvREFCNT_inc_NN
Identique à SvREFCNT_inc, mais ne peut être utilisé que si vous savez sv est non nulle. Depuis que nous
n'avez pas à vérifier le NULLness, c'est plus rapide et plus petit.

SV* SvREFCNT_inc_NN(SV* sv)

SvREFCNT_inc_simple
Identique à SvREFCNT_inc, mais ne peut être utilisé qu'avec des expressions sans effets secondaires.
Comme nous n'avons pas à stocker une valeur temporaire, c'est plus rapide.

SV* SvREFCNT_inc_simple(SV* sv)

SvREFCNT_inc_simple_NN
Identique à SvREFCNT_inc_simple, mais ne peut être utilisé que si vous savez sv est non nulle.
Comme nous n'avons pas à vérifier le NULLness, c'est plus rapide et plus petit.

SV* SvREFCNT_inc_simple_NN(SV* sv)

SvREFCNT_inc_simple_void
Identique à SvREFCNT_inc_simple, mais ne peut être utilisé que si vous n'avez pas besoin du retour
évaluer. La macro n'a pas besoin de renvoyer une valeur significative.

annuler SvREFCNT_inc_simple_void(SV* sv)

SvREFCNT_inc_simple_void_NN
Identique à SvREFCNT_inc, mais ne peut être utilisé que si vous n'avez pas besoin de la valeur de retour, et
Tu le sais sv est non nulle. La macro n'a pas besoin de renvoyer une valeur significative
valeur, ou vérifier NULLness, donc c'est plus petit et plus rapide.

annuler SvREFCNT_inc_simple_void_NN(SV* sv)

SvREFCNT_inc_void
Identique à SvREFCNT_inc, mais ne peut être utilisé que si vous n'avez pas besoin de la valeur de retour.
La macro n'a pas besoin de renvoyer une valeur significative.

annuler SvREFCNT_inc_void(SV* sv)

SvREFCNT_inc_void_NN
Identique à SvREFCNT_inc, mais ne peut être utilisé que si vous n'avez pas besoin de la valeur de retour, et
Tu le sais sv est non nulle. La macro n'a pas besoin de renvoyer une valeur significative
valeur, ou vérifier NULLness, donc c'est plus petit et plus rapide.

annuler SvREFCNT_inc_void_NN(SV* sv)

SvROK Teste si le SV est un RV.

U32 SvROK(SV* sv)

SvROK_off
Annule l'état RV d'un SV.

annuler SvROK_off(SV* sv)

SvROK_on
Indique à un SV qu'il s'agit d'un RV.

annuler SvROK_on(SV* sv)

SvRV Déréférence un RV pour renvoyer le SV.

SV* SVRV(SV* SV)

SvRV_set
Définissez la valeur du pointeur RV dans sv sur val. Voir "SvIV_set".

void SvRV_set(SV* sv, SV* val)

SvSTASH Renvoie la réserve du SV.

HV* SvSTASH(SV* sv)

SvSTASH_set
Définissez la valeur du pointeur STASH dans sv sur val. Voir "SvIV_set".

void SvSTASH_set(SV* sv, HV* val)

SvTAINT Tache un SV si le tainting est activé, et si une entrée à l'expression actuelle
est entaché - généralement une variable, mais peut-être aussi des entrées implicites telles que les paramètres régionaux
réglages. "SvTAINT" propage cette souillure aux sorties d'une expression
de façon pessimiste ; c'est-à-dire sans prêter attention à
les sorties sont influencées par quelles entrées.

annuler SvTAINT(SV* sv)

TEINTÉ
Vérifie si un SV est entaché. Renvoie TRUE si c'est le cas, FALSE sinon.

booléen SvTAINTED(SV* sv)

SvTAINTED_off
Nettoie un SV. Être très prudent avec cette routine, car elle court-circuite certains
Fonctionnalités de sécurité fondamentales de Perl. Les auteurs du module XS ne doivent pas l'utiliser
fonctionner à moins qu'ils ne comprennent pleinement toutes les implications d'un
sans entacher la valeur. L'élimination des taches doit être effectuée de la manière standard de Perl, via
une expression rationnelle soigneusement conçue, plutôt que de supprimer directement les variables.

annuler SvTAINTED_off(SV* sv)

SvTAINTED_on
Marque un SV comme souillé si le souillement est activé.

annuler SvTAINTED_on(SV* sv)

SvTRUE Renvoie un booléen indiquant si Perl évaluerait le SV comme vrai ou faux.
See SvOK() pour un test défini/indéfini. Gère la magie 'get' à moins que le scalaire ne soit
déjà SvPOK, SvIOK ou SvNOK (le public, pas les drapeaux privés).

booléen SvTRUE(SV* sv)

SvTRUE_nomg
Renvoie un booléen indiquant si Perl évaluerait le SV comme vrai ou faux.
See SvOK() pour un test défini/indéfini. Ne gère pas la magie 'get'.

booléen SvTRUE_nomg(SV* sv)

SvTYPE Renvoie le type de SV. Voir "svtype".

svtype SvTYPE(SV* sv)

SvUOK Renvoie un booléen indiquant si la SV contient un entier qui doit être
interprété comme non signé. Un entier non négatif dont la valeur est comprise dans la plage
d'un IV et d'un UV peuvent être signalés comme SvUOK ou SVIOK.

booléen SvUOK(SV* sv)

SvMISE À NIVEAU
Utilisé pour mettre à niveau un SV vers un formulaire plus complexe. Utilise "sv_upgrade" pour effectuer la
mettre à niveau si nécessaire. Voir "svtype".

void SvUPGRADE(SV* sv, type svtype)

SvUTF8 Renvoie une valeur U32 indiquant l'état UTF-8 d'un SV. Si les choses sont mises en place
correctement, cela indique si oui ou non le SV contient des données encodées en UTF-8. Tu
devrait utiliser ceci après un appel à SvPV() ou l'une de ses variantes, en cas d'appel à
la surcharge de chaîne met à jour le drapeau interne.

Si vous souhaitez prendre en compte le pragma bytes, utilisez plutôt "DO_UTF8".

U32 SvUTF8(SV*sv)

SvUTF8_off
Annule le statut UTF-8 d'un SV (les données ne sont pas modifiées, juste le drapeau). Ne pas
utiliser à la légère.

annuler SvUTF8_off(SV *sv)

SvUTF8_on
Activez le statut UTF-8 d'un SV (les données ne sont pas modifiées, juste le drapeau). Fais
pas utiliser à la légère.

annuler SvUTF8_on(SV *sv)

SvUV Contraint le SV donné à un entier non signé et le renvoie. Voir "SvUVx" pour un
version qui garantit de n'évaluer sv qu'une seule fois.

UVSvUV(SV* sv)

SvUVX Renvoie la valeur brute dans le slot UV du SV, sans contrôles ni conversions. Seulement
à utiliser lorsque vous êtes sûr que SvIOK est vrai. Voir aussi "SvUV()".

UV SvUVX(SV* sv)

SvUVx Contraint le SV donné à un entier non signé et le renvoie. Garanties à
évaluer "sv" une seule fois. N'utilisez ceci que si "sv" est une expression avec côté
effets, sinon utilisez le "SvUV" plus efficace.

UV SvUVx(SV* sv)

SvUV_nomg
Comme "SvUV" mais ne traite pas la magie.

UV SvUV_nomg(SV* sv)

SvUV_set
Définissez la valeur du pointeur UV dans sv sur val. Voir "SvIV_set".

void SvUV_set(SV* sv, UV val)

SvVOK Renvoie un booléen indiquant si le SV contient une v-string.

booléen SvVOK(SV* sv)

sv_catpvn_nomg
Comme "sv_catpvn" mais ne traite pas la magie.

void sv_catpvn_nomg(SV* sv, const char* ptr,
STRLEN len)

sv_catpv_nomg
Comme "sv_catpv" mais ne traite pas la magie.

void sv_catpv_nomg(SV* sv, const char* ptr)

sv_catsv_nomg
Comme "sv_catsv" mais ne traite pas la magie.

annuler sv_catsv_nomg(SV* dsv, SV* ssv)

sv_derived_from
Exactement comme "sv_derived_from_pv", mais ne prend pas de paramètre "flags".

bool sv_derived_from(SV* sv, const char *const nom)

sv_derived_from_pv
Exactement comme "sv_derived_from_pvn", mais prend une chaîne terminée par un caractère nul au lieu d'un
paire chaîne/longueur.

booléen sv_derived_from_pv(SV* sv,
caractère const * nom const,
drapeaux U32)

sv_derived_from_pvn
Renvoie un booléen indiquant si le SV est dérivé de la classe spécifiée at
le C niveau. Pour vérifier la dérivation au niveau Perl, appelez "isa()" comme un Perl normal
méthode.

Actuellement, la seule valeur significative pour les « drapeaux » est SVf_UTF8.

booléen sv_derived_from_pvn(SV* sv,
caractère const * nom const,
const STRLEN len, drapeaux U32)

sv_derived_from_sv
Exactement comme "sv_derived_from_pvn", mais prend la chaîne de nom sous la forme d'un SV
au lieu d'une paire chaîne/longueur.

bool sv_derived_from_sv(SV* sv, SV *namesv,
drapeaux U32)

sv_does Comme "sv_does_pv", mais ne prend pas de paramètre "flags".

bool sv_does(SV* sv, const char *const nom)

sv_does_pv
Comme "sv_does_sv", mais prend une chaîne terminée par un caractère nul au lieu d'un SV.

bool sv_does_pv(SV* sv, const char *const nom,
drapeaux U32)

sv_does_pvn
Comme "sv_does_sv", mais prend une paire chaîne/longueur au lieu d'un SV.

bool sv_does_pvn(SV* sv, const char *const nom,
const STRLEN len, drapeaux U32)

sv_does_sv
Renvoie un booléen indiquant si le SV exécute un rôle nommé spécifique. La
SV peut être un objet Perl ou le nom d'une classe Perl.

bool sv_does_sv(SV* sv, SV* nomsv, drapeaux U32)

sv_report_used
Vider le contenu de tous les SV non encore libérés (aide au débogage).

annuler sv_report_used()

sv_setsv_nomg
Comme "sv_setsv" mais ne traite pas la magie.

void sv_setsv_nomg(SV* dsv, SV* ssv)

sv_utf8_upgrade_nomg
Comme sv_utf8_upgrade, mais ne fait pas de magie sur "sv".

STRLEN sv_utf8_upgrade_nomg(NN SV *sv)

SV-Corps Allocation

look_like_number
Testez si le contenu d'un SV ressemble à un nombre (ou est un nombre). "Inf" et
"Infinity" sont traités comme des nombres (donc n'émettra pas d'avertissement non numérique), même
si votre atof() ne les grok pas. Get-magic est ignoré.

I32 ressemble_nombre_(SV *const sv)

nouveauRV_noinc
Crée un wrapper RV pour un SV. Le nombre de références pour le SV d'origine est pas
incrémenté.

SV* nouveauRV_noinc(SV *const tmpRef)

newSV Crée un nouveau SV. Un paramètre "len" différent de zéro indique le nombre d'octets de
espace de chaîne préalloué que le SV devrait avoir. Un octet supplémentaire pour un "NUL" de fin
est également réservé. (SvPOK n'est pas défini pour le SV même si l'espace de chaîne est
alloué.) Le décompte de référence pour le nouveau SV est défini sur 1.

En 5.9.3, nouveauSV() remplace l'ancien NOUVELLESV() API, et supprime le premier paramètre,
x, une aide au débogage qui permettait aux appelants de s'identifier. Cette aide a été
remplacée par une nouvelle option de construction, PERL_MEM_LOG (voir "PERL_MEM_LOG" dans
perlhacktips). L'ancienne API est toujours là pour être utilisée dans les modules XS prenant en charge
perles plus anciennes.

SV* nouveauSV(const STRLEN len)

nouveauSVhek
Crée un nouveau SV à partir de la structure de la clé de hachage. Il générera des scalaires qui pointent
à la table de chaînes partagées si possible. Renvoie un nouveau SV (indéfini) si le
hek est NULL.

SV* nouveauSVhek(const HEK *const hek)

newSViv Crée un nouveau SV et y copie un entier. Le décompte de référence pour le SV est
mis à 1.

SV* nouveauSViv(const IV i)

newSVnv Crée un nouveau SV et y copie une valeur à virgule flottante. Le nombre de références
pour le SV est fixé à 1.

SV* nouveauSVnv(const NV n)

newSVpv Crée un nouveau SV et copie une chaîne (qui peut contenir des caractères "NUL" ("\0")
dans ça. Le décompte de référence pour le SV est fixé à 1. Si "len" est zéro, Perl
calculer la longueur en utilisant strlen(), (ce qui signifie que si vous utilisez cette option, ce "s"
ne peut pas avoir de caractères "NUL" intégrés et doit avoir un octet "NUL" de fin).

Pour plus d'efficacité, pensez à utiliser "newSVpvn" à la place.

SV* nouveauSVpv(const char *const s, const STRLEN len)

nouveauSVpvf
Crée un nouveau SV et l'initialise avec la chaîne formatée comme "sprintf".

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

nouveauSVpvn
Crée un nouveau SV et y copie une chaîne, qui peut contenir des caractères "NUL"
("\0") et d'autres données binaires. Le décompte de référence pour le SV est défini sur 1. Remarque
que si "len" vaut zéro, Perl créera une chaîne de longueur nulle (Perl). Tu es
responsable de s'assurer que le tampon source fait au moins "len" octets de long. Si
l'argument "buffer" est NULL le nouveau SV sera indéfini.

SV* nouveauSVpvn(const char *const s, const STRLEN len)

nouveauSVpvn_flags
Crée un nouveau SV et copie une chaîne (qui peut contenir des caractères "NUL" ("\0")
dans ça. Le décompte de référence pour le SV est défini sur 1. Notez que si "len" est égal à zéro,
Perl créera une chaîne de longueur nulle. Vous êtes responsable de vous assurer que le
La chaîne source est longue d'au moins "len" octets. Si l'argument "s" est NULL, le nouveau
SV sera indéfini. Actuellement, les seuls bits de drapeau acceptés sont "SVf_UTF8" et
"SVs_TEMP". Si "SVs_TEMP" est défini, alors "sv_2mortal()" est appelé sur le résultat
avant de revenir. Si "SVf_UTF8" est défini, "s" est considéré comme étant en UTF-8 et le
L'indicateur "SVf_UTF8" sera défini sur le nouveau SV. "newSVpvn_utf8()" est une commodité
wrapper pour cette fonction, défini comme

#define newSVpvn_utf8(s, len, u) \
nouveauSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)

SV* newSVpvn_flags(const char *const s,
const STRLEN len,
drapeaux const U32)

nouveauSVpvn_share
Crée un nouveau SV avec son SvPVX_const pointant vers une chaîne partagée dans la chaîne
table. Si la chaîne n'existe pas déjà dans la table, elle est créée en premier.
Active le drapeau SvIsCOW (ou READONLY et FAKE dans 5.16 et versions antérieures). Si la
le paramètre "hash" est différent de zéro, cette valeur est utilisée ; sinon le hachage est calculé.
Le hachage de la chaîne peut ensuite être récupéré à partir du SV avec le "SvSHARED_HASH()"
macro. L'idée ici est que, comme la table de chaînes est utilisée pour les clés de hachage partagées
ces chaînes auront SvPVX_const == HeKEY et la recherche de hachage évitera la chaîne
comparer.

SV* newSVpvn_share(const char* s, longueur I32, hachage U32)

nouveauSVpvs
Comme "newSVpvn", mais prend une chaîne littérale terminée par "NUL" au lieu d'un
paire chaîne/longueur.

SV* nouveauSVpvs(const char* s)

nouveauSVpvs_flags
Comme "newSVpvn_flags", mais prend une chaîne littérale terminée par "NUL" au lieu d'un
paire chaîne/longueur.

SV* newSVpvs_flags(const char* s, drapeaux U32)

nouveauSVpvs_share
Comme "newSVpvn_share", mais prend une chaîne littérale terminée par "NUL" au lieu d'un
paire chaîne/longueur et omet le paramètre de hachage.

SV* nouveauSVpvs_share(const char* s)

nouveauSVpv_share
Comme "newSVpvn_share", mais prend une chaîne terminée par "NUL" au lieu d'un
paire chaîne/longueur.

SV* newSVpv_share(const char* s, hachage U32)

newSVrv Crée un nouveau SV pour le RV existant, "rv", vers lequel pointer. Si "rv" n'est pas un RV
alors il sera mis à niveau vers un. Si "classname" n'est pas nul, le nouveau SV sera
être béni dans le package spécifié. Le nouveau SV est renvoyé et sa référence
count est 1. Le nombre de références 1 appartient à "rv".

SV* nouveauSVrv(SV *const rv,
const char * nom de classe const)

newSVsv Crée un nouveau SV qui est une copie exacte du SV d'origine. (Les usages
"sv_setsv".)

SV* nouveauSVsv(SV *const ancien)

newSVuv Crée un nouveau SV et y copie un entier non signé. Le nombre de références pour
le SV est fixé à 1.

SV* nouveauSVuv(const UV u)

nouveautype_SV
Crée un nouveau SV, du type spécifié. Le décompte de référence pour le nouveau SV est
mis à 1.

SV* nouveauSV_type(const svtype type)

sv_2bool
Cette macro n'est utilisée que par sv_true() ou son équivalent macro, et seulement si le
l'argument de ce dernier n'est ni SvPOK, SvIOK ni SvNOK. Il appelle sv_2bool_flags avec
le drapeau SV_GMAGIC.

booléen sv_2bool(SV *const sv)

sv_2bool_flags
Cette fonction n'est utilisée que par sv_true() et amis, et seulement si ce dernier est
l'argument n'est ni SvPOK, SvIOK ni SvNOK. Si les drapeaux contiennent SV_GMAGIC, alors
ça fait un mg_get() d'abord.

bool sv_2bool_flags(SV *sv, drapeaux I32)

sv_2cv En utilisant divers gambits, essayez d'obtenir un CV d'un SV ; de plus, essayez si possible de
définissez *st et *gvp sur le stash et le GV qui lui sont associés. Les drapeaux dans "lref" sont
passé à gv_fetchsv.

CV* sv_2cv(SV* sv, HV **const st, GV **const gvp,
const I32 lréf)

sv_2io En utilisant divers gambits, essayez d'obtenir un IO d'un SV : le slot IO s'il s'agit d'un GV ; ou
le résultat récursif si nous sommes un RV ; ou l'emplacement IO du symbole nommé d'après le
PV si nous sommes une chaîne.

La magie 'Get' est ignorée sur le sv transmis, mais sera appelée sur "SvRV(sv)" si sv
est un camping-car.

IO* sv_2io(SV *const sv)

sv_2iv_flags
Renvoie la valeur entière d'un SV, en effectuant toute conversion de chaîne nécessaire. Si
flags inclut SV_GMAGIC, fait un mg_get() première. Normalement utilisé via le
Macros "SvIV(sv)" et "SvIVx(sv)".

IV sv_2iv_flags (SV *const sv, const I32 drapeaux)

sv_2mortel
Marque un SV existant comme mortel. Le SV sera détruit "prochainement", soit par un
appel explicite à FREETMPS, ou par un appel implicite à des endroits tels que statement
limites. SvTEMP() est activé, ce qui signifie que le tampon de chaîne du SV peut être
"volé" si cette SV est copiée. Voir aussi "sv_newmortal" et "sv_mortalcopy".

SV* sv_2mortel(SV *const sv)

sv_2nv_flags
Renvoie la valeur numérique d'un SV, en effectuant toute conversion de chaîne ou d'entier nécessaire.
Si flags inclut SV_GMAGIC, est-ce qu'un mg_get() première. Normalement utilisé via le
Macros "SvNV(sv)" et "SvNVx(sv)".

NV sv_2nv_flags (SV *const sv, const I32 drapeaux)

sv_2pvoctet
Renvoyez un pointeur vers la représentation codée en octets du SV et définissez *lp sur son
longueur. Peut entraîner le déclassement du SV de UTF-8 comme effet secondaire.

Généralement accessible via la macro "SvPVbyte".

char* sv_2pvbyte(SV *sv, STRLEN *const lp)

sv_2pvutf8
Renvoyez un pointeur vers la représentation encodée en UTF-8 du SV et définissez *lp sur son
longueur. Peut entraîner la mise à niveau du SV vers UTF-8 comme effet secondaire.

Généralement accessible via la macro "SvPVutf8".

char* sv_2pvutf8(SV *sv, STRLEN *const lp)

sv_2pv_flags
Renvoie un pointeur vers la valeur de chaîne d'un SV et définit *lp sur sa longueur. Si
flags inclut SV_GMAGIC, fait un mg_get() première. Contraint sv à une chaîne si
nécessaire. Normalement invoqué via la macro "SvPV_flags". "sv_2pv()" et
"sv_2pv_nomg" se retrouve généralement ici aussi.

char* sv_2pv_flags(SV *const sv, STRLEN *const lp,
const drapeaux I32)

sv_2uv_flags
Renvoie la valeur entière non signée d'un SV, en effectuant toute conversion de chaîne nécessaire.
Si flags inclut SV_GMAGIC, est-ce qu'un mg_get() première. Normalement utilisé via le
Macros "SvUV(sv)" et "SvUVx(sv)".

UV sv_2uv_flags (SV *const sv, const I32 drapeaux)

sv_backoff
Supprimez tout décalage de chaîne. Vous devez normalement utiliser le wrapper de macro "SvOOK_off"
à la place.

int sv_backoff(SV *const sv)

sv_bless
Bénit un SV dans un package spécifié. Le SV doit être un VR. Le colis doit
être désigné par sa réserve (voir "gv_stashpv()"). Le décompte de référence du SV est
non affecté.

SV* sv_bless(SV *const sv, HV *const cachette)

sv_catpv
Concatène la chaîne terminée par "NUL" à la fin de la chaîne qui se trouve dans
le SV. Si le SV a le statut UTF-8 défini, les octets ajoutés doivent être
UTF-8 valide. Gère la magie 'get', mais pas la magie 'set'. Voir "sv_catpv_mg".

void sv_catpv(SV *const sv, const char* ptr)

sv_catpvf
Traite ses arguments comme "sprintf" et ajoute la sortie formatée à un SV.
Si les données ajoutées contiennent des caractères "larges" (y compris, mais sans s'y limiter,
SV avec un PV UTF-8 formaté avec %s, et des caractères >255 formatés avec %c), le
SV d'origine peut être mis à niveau vers UTF-8. Gère la magie 'get', mais pas 'set'
la magie. Voir "sv_catpvf_mg". Si le SV d'origine était UTF-8, le modèle devrait être
UTF-8 valide ; si le SV d'origine était des octets, le modèle devrait l'être aussi.

void sv_catpvf(SV *const sv, const char *const pat,
...)

sv_catpvf_mg
Comme "sv_catpvf", mais gère également la magie "set".

void sv_catpvf_mg(SV *const sv,
const char *const pat, ...)

sv_catpvn
Concatène la chaîne à la fin de la chaîne qui se trouve dans le SV. Le "len"
indique le nombre d'octets à copier. Si le SV a le statut UTF-8 défini, alors le
les octets ajoutés doivent être en UTF-8 valide. Gère la magie 'get', mais pas la magie 'set'.
Voir "sv_catpvn_mg".

void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)

sv_catpvn_flags
Concatène la chaîne à la fin de la chaîne qui se trouve dans le SV. Le "len"
indique le nombre d'octets à copier.

Par défaut, la chaîne ajoutée est supposée être valide UTF-8 si le SV a le
Statut UTF-8 défini, et une chaîne d'octets dans le cas contraire. On peut forcer l'ajout
chaîne à interpréter en UTF-8 en fournissant le drapeau "SV_CATUTF8", et en octets
en fournissant le drapeau "SV_CATBYTES" ; le SV ou la chaîne ajoutée sera
mise à niveau vers UTF-8 si nécessaire.

Si "flags" a le bit "SV_SMAGIC" défini, sera "mg_set" sur "dsv" par la suite si
approprié. "sv_catpvn" et "sv_catpvn_nomg" sont implémentés en fonction de cela
la fonction.

void sv_catpvn_flags(SV *const dstr,
caractère const *sstr,
const STRLEN len,
const drapeaux I32)

sv_catpvs
Comme "sv_catpvn", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

void sv_catpvs(SV* sv, const char* s)

sv_catpvs_flags
Comme "sv_catpvn_flags", mais prend une chaîne littérale terminée par "NUL" au lieu d'un
paire chaîne/longueur.

void sv_catpvs_flags(SV* sv, const char* s,
drapeaux I32)

sv_catpvs_mg
Comme "sv_catpvn_mg", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

void sv_catpvs_mg(SV* sv, const char* s)

sv_catpvs_nomg
Comme "sv_catpvn_nomg", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

void sv_catpvs_nomg(SV* sv, const char* s)

sv_catpv_flags
Concatène la chaîne terminée par "NUL" à la fin de la chaîne qui se trouve dans
le SV. Si le SV a le statut UTF-8 défini, les octets ajoutés doivent être
UTF-8 valide. Si "flags" a le bit "SV_SMAGIC" défini, "mg_set" sur le
SV modifié le cas échéant.

void sv_catpv_flags(SV *dstr, const char *sstr,
const drapeaux I32)

sv_catpv_mg
Comme "sv_catpv", mais gère également la magie "set".

void sv_catpv_mg(SV *const sv, const char *const ptr)

sv_catsv
Concatène la chaîne de SV "ssv" à la fin de la chaîne dans SV "dsv". Si
"ssv" est nul, ne fait rien ; sinon modifie uniquement "dsv". Les poignées 'get' la magie
sur les deux SV, mais pas de magie "set". Voir "sv_catsv_mg" et "sv_catsv_nomg".

annuler sv_catsv(SV *dstr, SV *sstr)

sv_catsv_flags
Concatène la chaîne de SV "ssv" à la fin de la chaîne dans SV "dsv". Si
"ssv" est nul, ne fait rien ; sinon modifie uniquement "dsv". Si les "drapeaux" incluent
Le bit "SV_GMAGIC" défini appellera "mg_get" sur les deux SV si nécessaire. Si "drapeaux"
inclure "SV_SMAGIC", "mg_set" sera appelé sur le SV modifié par la suite, si
approprié. "sv_catsv", "sv_catsv_nomg" et "sv_catsv_mg" sont implémentés dans
termes de cette fonction.

void sv_catsv_flags(SV *const dsv, SV *const ssv,
const drapeaux I32)

sv_chop Suppression efficace des caractères depuis le début du tampon de chaîne.
SvPOK(sv), ou au moins SvPOKp(sv), doit être vrai et le "ptr" doit être un pointeur vers
quelque part dans le tampon de chaîne. Le "ptr" devient le premier caractère du
chaîne ajustée. Utilise le "hack OOK". Au retour, uniquement SvPOK(sv) et SvPOKp(sv)
parmi les drapeaux OK sera vrai.

Attention : après le retour de cette fonction, "ptr" et SvPVX_const(sv) peuvent ne plus faire référence
au même bloc de données.

La malheureuse similitude du nom de cette fonction avec celui de "chop" de Perl
l'opérateur est strictement fortuite. Cette fonction fonctionne à partir de la gauche ; "hacher"
travaille à partir de la droite.

void sv_chop(SV *const sv, const char *const ptr)

sv_clear
Effacer un SV : appelez tous les destructeurs, libérez toute mémoire utilisée par le corps et libérez
le corps lui-même. La tête du SV est pas libéré, bien que son type soit défini sur tous les 1
afin qu'il ne soit pas présumé par inadvertance être sous tension pendant la destruction mondiale
etc. Cette fonction ne doit être appelée que lorsque REFCNT vaut zéro. Le plus souvent
vous voudrez appeler "sv_free()" (ou son enveloppe de macro "SvREFCNT_dec") à la place.

annuler sv_clear(SV *const orig_sv)

sv_cmp Compare les chaînes dans deux SV. Renvoie -1, 0 ou 1 indiquant si le
chaîne dans "sv1" est inférieure, égale ou supérieure à la chaîne dans "sv2". Est
Conscient de l'UTF-8 et de l'utilisation des octets, les poignées deviennent magiques et contraindront ses arguments à
cordes si nécessaire. Voir aussi "sv_cmp_locale".

I32 sv_cmp(SV *const sv1, SV *const sv2)

sv_cmp_flags
Compare les chaînes dans deux SV. Renvoie -1, 0 ou 1 indiquant si le
chaîne dans "sv1" est inférieure, égale ou supérieure à la chaîne dans "sv2". Est
UTF-8 et 'use bytes' sont conscients et contraindront ses arguments en chaînes si nécessaire. Si
les drapeaux incluent SV_GMAGIC, il gère get magic. Voir également
"sv_cmp_locale_flags".

I32 sv_cmp_flags(SV *const sv1, SV *const sv2,
drapeaux const U32)

sv_cmp_locale
Compare les chaînes dans deux SV en tenant compte des paramètres régionaux. Est UTF-8 et 'utilisation
conscients des octets, les poignées deviennent magiques et contraindront ses arguments en chaînes si nécessaire.
Voir aussi "sv_cmp".

I32 sv_cmp_locale(SV *const sv1, SV *const sv2)

sv_cmp_locale_flags
Compare les chaînes dans deux SV en tenant compte des paramètres régionaux. Est UTF-8 et 'utilisation
bytes' conscient et contraindra ses arguments en chaînes si nécessaire. Si les drapeaux
contient SV_GMAGIC, il gère get magic. Voir aussi "sv_cmp_flags".

I32 sv_cmp_locale_flags(SV *const sv1,
SV *const sv2,
drapeaux const U32)

sv_collxfrm
Cela appelle "sv_collxfrm_flags" avec le drapeau SV_GMAGIC. Voir "sv_collxfrm_flags".

char* sv_collxfrm(SV *const sv, STRLEN *const nxp)

sv_collxfrm_flags
Ajoutez la magie Collate Transform à un SV s'il ne l'a pas déjà. Si les drapeaux
contient SV_GMAGIC, il gère get-magic.

Toute variable scalaire peut transporter la magie PERL_MAGIC_collxfrm qui contient le scalaire
données de la variable, mais transformées dans un format tel qu'une mémoire normale
comparaison peut être utilisé pour comparer les données en fonction des paramètres régionaux.

char* sv_collxfrm_flags(SV *const sv,
STRLEN *const nxp,
Drapeaux const I32)

sv_copypv_flags
Implémentation de sv_copypv et sv_copypv_nomg. Les appels deviennent magiques si les drapeaux incluent
SV_GMAGIC.

void sv_copypv_flags(SV *const dsv, SV *const ssv,
const drapeaux I32)

sv_copypv_nomg
Comme sv_copypv, mais n'invoque pas get magic en premier.

void sv_copypv_nomg(SV *const dsv, SV *const ssv)

sv_dec Auto-décrémentation de la valeur dans le SV, en effectuant une conversion de chaîne en numérique si
nécessaire. Gère la magie "get" et la surcharge de l'opérateur.

annuler sv_dec(SV *const sv)

sv_dec_nomg
Décrémentation automatique de la valeur dans le SV, en effectuant une conversion de chaîne en numérique si
nécessaire. Gère la surcharge de l'opérateur. Ignore la gestion de la magie "get".

annuler sv_dec_nomg(SV *const sv)

sv_eq Renvoie un booléen indiquant si les chaînes des deux SV sont identiques. Est
Conscient de l'UTF-8 et de l'utilisation des octets, les poignées deviennent magiques et contraindront ses arguments à
cordes si nécessaire.

I32 sv_eq(SV* sv1, SV* sv2)

sv_eq_flags
Renvoie un booléen indiquant si les chaînes des deux SV sont identiques. Est
UTF-8 et 'use bytes' sont conscients et forcent ses arguments en chaînes si nécessaire. Si la
flags incluent SV_GMAGIC, il gère également get-magic.

I32 sv_eq_flags(SV* sv1, SV* sv2, drapeaux const U32)

sv_force_normal_flags
Annulez divers types de fakery sur un SV, où fakery signifie "plus qu'" une chaîne : si
le PV est une chaîne partagée, faites une copie privée ; si nous sommes un arbitre, arrêtez d'arbitrer ; si
nous sommes un glob, rétrogradons vers un xpvmg ; si nous sommes un scalaire de copie sur écriture, c'est le
temps d'écriture lorsque nous faisons la copie, et est également utilisé localement ; si c'est une vstring,
laissez tomber la magie vstring. Si "SV_COW_DROP_PV" est défini, alors un scalaire de copie sur écriture
supprime son tampon PV (le cas échéant) et devient SvPOK_off plutôt que de faire une copie.
(Utilisé lorsque ce scalaire est sur le point d'être défini sur une autre valeur.) De plus, le
Le paramètre "flags" est passé à "sv_unref_flags()" lors de l'annulation.
"sv_force_normal" appelle cette fonction avec des drapeaux définis sur 0.

Cette fonction est censée être utilisée pour signaler à perl que ce SV est sur le point d'être
écrit, et toute comptabilité supplémentaire doit être prise en charge. Par conséquent, il
croasse sur les valeurs en lecture seule.

void sv_force_normal_flags(SV *const sv,
drapeaux const U32)

sv_free Décrémente le nombre de références d'un SV, et s'il tombe à zéro, appelez "sv_clear" pour
invoquer des destructeurs et libérer toute mémoire utilisée par le corps ; enfin, désaffecter
la tête du SV lui-même. Normalement appelé via une macro wrapper "SvREFCNT_dec".

annuler sv_free(SV *const sv)

sv_gets Obtenir une ligne du descripteur de fichier et la stocker dans le SV, en l'ajoutant éventuellement à
la chaîne actuellement stockée. Si "append" n'est pas 0, la ligne est ajoutée au SV
au lieu de l'écraser. "append" doit être défini sur le décalage d'octet que le
la chaîne ajoutée doit commencer à dans le SV (généralement, "SvCUR(sv)" est un
choix).

char* sv_gets(SV *const sv, PerlIO *const fp,
I32 annexe)

sv_get_backrefs
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Si le sv est la cible d'une référence faible, il renvoie les références arrière
structure associée au sv; sinon renvoie NULL.

Lors du retour d'un résultat non nul, le type de retour est pertinent. S'il s'agit d'un
AV alors les éléments de l'AV sont les RV faibles de référence qui pointent vers ce
Objet. S'il s'agit d'un autre type, l'élément lui-même est la référence faible.

Voir aussi Perl_sv_add_backref(), Perl_sv_del_backref(), Perl_sv_kill_backrefs()

SV* sv_get_backrefs(SV *const sv)

sv_grow Développe le tampon de caractères dans le SV. Si nécessaire, utilise "sv_unref" et
met à niveau le SV vers "SVt_PV". Renvoie un pointeur vers le tampon de caractères. Utilisez le
Enveloppe "SvGROW" à la place.

char* sv_grow(SV *const sv, STRLEN newlen)

sv_inc Auto-incrémentation de la valeur dans le SV, en effectuant une conversion de chaîne en numérique si
nécessaire. Gère la magie "get" et la surcharge de l'opérateur.

annuler sv_inc(SV *const sv)

sv_inc_nomg
Auto-incrémentation de la valeur dans le SV, en effectuant une conversion de chaîne en numérique si
nécessaire. Gère la surcharge de l'opérateur. Ignore la gestion de la magie "get".

annuler sv_inc_nomg(SV *const sv)

sv_insert
Insère une chaîne au décalage/longueur spécifié dans la SV. Semblable à la
Perl substr () fonction. Les poignées deviennent magiques.

void sv_insert(SV *const bigstr, const STRLEN offset,
const STRLEN len,
const char *const peu,
const STRLEN petitlen)

sv_insert_flags
Identique à "sv_insert", mais les "drapeaux" supplémentaires sont passés au "SvPV_force_flags"
qui s'applique à "bigstr".

void sv_insert_flags(SV *const bigstr,
décalage STRLEN const,
const STRLEN len,
const char *const peu,
const STRLEN petitlen,
drapeaux const U32)

sv_isa Renvoie un booléen indiquant si le SV est béni dans la classe spécifiée.
Cela ne vérifie pas les sous-types ; utiliser "sv_derived_from" pour vérifier un héritage
relation.

int sv_isa(SV* sv, const char *const nom)

sv_isobject
Renvoie un booléen indiquant si le SV est un RV pointant vers un objet béni.
Si le SV n'est pas un RV, ou si l'objet n'est pas béni, alors cela reviendra
faux

int sv_isobject(SV* sv)

sv_len Renvoie la longueur de la chaîne dans le SV. Gère la magie et la coercition de type et
définit le drapeau UTF8 de manière appropriée. Voir aussi "SvCUR", qui donne un accès brut au
emplacement xpv_cur.

STRLEN sv_len(SV *const sv)

sv_len_utf8
Renvoie le nombre de caractères dans la chaîne dans un SV, en comptant les octets larges UTF-8
comme un seul personnage. Gère la magie et la coercition de type.

STRLEN sv_len_utf8(SV *const sv)

sv_magique
Ajoute de la magie à un SV. Mettez d'abord à jour "sv" pour taper "SVt_PVMG" si nécessaire, puis
ajoute un nouvel élément magique de type "comment" à la tête de la liste magique.

Voir "sv_magicext" (que "sv_magic" appelle maintenant) pour une description de la manipulation
des arguments "name" et "namlen".

Vous devez utiliser "sv_magicext" pour ajouter de la magie aux SV SvREADONLY et également pour en ajouter d'autres
plus d'une instance du même "comment".

void sv_magic(SV *const sv, SV *const obj,
const int comment, const char *const nom,
const I32 nom)

sv_magicext
Ajoute de la magie à un SV, en l'améliorant si nécessaire. Applique la vtable fournie et
renvoie un pointeur vers la magie ajoutée.

Notez que "sv_magicext" autorisera des choses que "sv_magic" ne permettra pas. Dans
particulier, vous pouvez ajouter de la magie aux SV SvREADONLY et ajouter plus d'une instance de
le même "comment".

Si "namlen" est supérieur à zéro alors un "savepvn" copier de "nom" est stocké, si
"namlen" vaut zéro alors "name" est stocké tel quel et - comme autre cas particulier - si
"(name && namlen == HEf_SVKEY)" alors "name" est supposé contenir un "SV*" et est
stocké tel quel avec son REFCNT incrémenté.

(Ceci est maintenant utilisé comme sous-programme par "sv_magic".)

MAGIE * sv_magicext(SV *const sv, SV *const obj,
const comment,
const MGVTBL *const vtbl,
caractère const * nom const,
const I32 nom)

sv_mortalcopy
Crée un nouveau SV qui est une copie du SV original (en utilisant "sv_setsv"). Le nouveau
SV est marqué comme mortel. Il sera détruit "prochainement", soit par un appel explicite
à FREETMPS, ou par un appel implicite à des endroits tels que les limites des instructions. Voir
également "sv_newmortal" et "sv_2mortal".

SV* sv_mortalcopy(SV *const oldsv)

sv_newmortal
Crée un nouveau SV nul qui est mortel. Le décompte de référence du SV est défini sur 1.
Il sera détruit "prochainement", soit par un appel explicite à FREETMPS, soit par un
appel implicite à des endroits tels que les limites de l'instruction. Voir aussi "sv_mortalcopy"
et "sv_2mortal".

SV* sv_nouveaumortel()

sv_newref
Incrémente le nombre de références d'un SV. Utilisez plutôt le wrapper "SvREFCNT_inc()".

SV* sv_newref(SV *const sv)

sv_pos_b2u
Convertit la valeur pointée par offsetp à partir d'un nombre d'octets depuis le début de
la chaîne, en comptant le nombre équivalent de caractères UTF-8. Manie la magie et
coercition de type.

Utilisez "sv_pos_b2u_flags" de préférence, qui gère correctement les chaînes plus longues que
2Gb.

void sv_pos_b2u(SV *const sv, I32 *const offsetp)

sv_pos_b2u_flags
Convertit le décalage d'un nombre d'octets depuis le début de la chaîne en un nombre
du nombre équivalent de caractères UTF-8. Gère la coercition de type. drapeaux est passé
à "SvPV_flags", et devrait généralement être "SV_GMAGIC|SV_CONST_RETURN" pour gérer
la magie.

STRLEN sv_pos_b2u_flags(SV *const sv,
décalage const STRLEN, drapeaux U32)

sv_pos_u2b
Convertit la valeur pointée par offsetp à partir d'un nombre de caractères UTF-8 de la
début de la chaîne, à un décompte du nombre équivalent d'octets ; si lenp n'est pas
zéro, il fait la même chose pour lenp, mais cette fois en partant de l'offset, plutôt
que depuis le début de la chaîne. Gère la magie et la coercition de type.

Utilisez "sv_pos_u2b_flags" de préférence, qui gère correctement les chaînes plus longues que
2Gb.

void sv_pos_u2b(SV *const sv, I32 *const offsetp,
I32 *const lenp)

sv_pos_u2b_flags
Convertit le décalage d'un nombre de caractères UTF-8 à partir du début de la chaîne en un
comptage du nombre équivalent d'octets ; si lenp est différent de zéro, il fait la même chose pour
lenp, mais cette fois en partant du décalage, plutôt qu'à partir du début du
chaîne de caractères. Gère la coercition de type. drapeaux est passé à "SvPV_flags", et généralement
devrait être "SV_GMAGIC|SV_CONST_RETURN" pour gérer la magie.

STRLEN sv_pos_u2b_flags(SV *const sv, STRLEN uoffset,
STRLEN * const lenp, drapeaux U32)

sv_pvbyten_force
Le backend pour la macro "SvPVbytex_force". Utilisez toujours la macro à la place.

char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)

sv_pvn_force
Obtenez une chaîne sensible du SV d'une manière ou d'une autre. Une implémentation privée du
Macro "SvPV_force" pour les compilateurs qui ne peuvent pas gérer les expressions de macro complexes.
Utilisez toujours la macro à la place.

char* sv_pvn_force(SV* sv, STRLEN* lp)

sv_pvn_force_flags
Obtenez une chaîne sensible du SV d'une manière ou d'une autre. Si "flags" a le bit "SV_GMAGIC" activé,
"mg_get" sur "sv" le cas échéant, sinon non. "sv_pvn_force" et
"sv_pvn_force_nomg" sont implémentés en termes de cette fonction. Vous voulez normalement
pour utiliser les différentes macros wrapper à la place : voir "SvPV_force" et "SvPV_force_nomg"

char* sv_pvn_force_flags(SV *const sv,
STRLEN *const lp,
const drapeaux I32)

sv_pvutf8n_force
Le backend pour la macro "SvPVutf8x_force". Utilisez toujours la macro à la place.

char* sv_pvutf8n_force(SV *const sv, STRLEN *const lp)

sv_reftype
Renvoie une chaîne décrivant à quoi le SV est une référence.

const char* sv_reftype(const SV *const sv, const int ob)

sv_replace
Faites du premier argument une copie du second, puis supprimez l'original. La
la SV cible prend physiquement possession du corps de la SV source et
hérite de ses drapeaux ; cependant, la cible garde toute magie qu'elle possède et toute magie dans
la source est rejetée. Notez qu'il s'agit d'une copie SV plutôt spécialisée
opération; la plupart du temps, vous voudrez utiliser "sv_setsv" ou l'une de ses nombreuses macros
parties avant.

void sv_replace(SV *const sv, SV *const nsv)

sv_reset
Implémentation sous-jacente pour la fonction Perl "reset". Notez que le niveau perl
fonction est vaguement obsolète.

void sv_reset (const char* s, HV *const stash)

sv_rvweaken
Affaiblir une référence : définir le drapeau "SvWEAKREF" sur ce RV ; donner le SV référencé
Magie "PERL_MAGIC_backref" si ce n'est déjà fait ; et poussez une référence arrière à ceci
RV sur le tableau de backreferences associé à cette magie. Si le VR est
magique, la magie d'ensemble sera appelée une fois le RV effacé.

SV* sv_rvweaken(SV *const sv)

sv_setiv
Copie un entier dans le SV donné, en mettant à jour d'abord si nécessaire. Ne fait pas
gérer la magie 'set'. Voir aussi "sv_setiv_mg".

void sv_setiv(SV *const sv, const IV num)

sv_setiv_mg
Comme "sv_setiv", mais gère également la magie "set".

void sv_setiv_mg(SV *const sv, const IV i)

sv_setnv
Copie un double dans le SV donné, en mettant à jour d'abord si nécessaire. Ne gère pas
'set' magique. Voir aussi "sv_setnv_mg".

void sv_setnv(SV *const sv, const NV num)

sv_setnv_mg
Comme "sv_setnv", mais gère également la magie "set".

void sv_setnv_mg(SV *const sv, const NV num)

sv_setpv
Copie une chaîne dans un SV. La chaîne doit se terminer par un caractère "NUL".
Ne gère pas la magie 'set'. Voir "sv_setpv_mg".

void sv_setpv(SV *const sv, const char *const ptr)

sv_setpvf
Fonctionne comme "sv_catpvf" mais copie le texte dans le SV au lieu de l'ajouter.
Ne gère pas la magie 'set'. Voir "sv_setpvf_mg".

void sv_setpvf(SV *const sv, const char *const pat,
...)

sv_setpvf_mg
Comme "sv_setpvf", mais gère également la magie 'set'.

void sv_setpvf_mg(SV *const sv,
const char *const pat, ...)

sv_setpviv
Copie un entier dans le SV donné, mettant également à jour sa valeur de chaîne. Ne fait pas
gérer la magie 'set'. Voir "sv_setpviv_mg".

void sv_setpviv(SV *const sv, const IV num)

sv_setpviv_mg
Comme "sv_setpviv", mais gère également la magie "set".

void sv_setpviv_mg(SV *const sv, const IV iv)

sv_setpvn
Copie une chaîne (contenant éventuellement des caractères "NUL" intégrés) dans un SV. La
Le paramètre "len" indique le nombre d'octets à copier. Si l'argument "ptr"
est NULL, le SV deviendra indéfini. Ne gère pas la magie 'set'. Voir
"sv_setpvn_mg".

void sv_setpvn(SV *const sv, const char *const ptr,
const STRLEN len)

sv_setpvn_mg
Comme "sv_setpvn", mais gère également la magie 'set'.

void sv_setpvn_mg(SV *const sv,
const char *const ptr,
const STRLEN len)

sv_setpvs
Comme "sv_setpvn", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

void sv_setpvs(SV* sv, const char* s)

sv_setpvs_mg
Comme "sv_setpvn_mg", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

void sv_setpvs_mg(SV* sv, const char* s)

sv_setpv_mg
Comme "sv_setpv", mais gère également la magie "set".

void sv_setpv_mg(SV *const sv, const char *const ptr)

sv_setref_iv
Copie un entier dans un nouveau SV, bénissant éventuellement le SV. L'argument « rv »
sera transformé en VR. Ce RV sera modifié pour pointer vers le nouveau SV. La
L'argument "classname" indique le package pour la bénédiction. Définissez "nom de classe" sur
"NULL" pour éviter la bénédiction. Le nouveau SV aura un nombre de références de 1, et
le RV sera retourné.

SV* sv_setref_iv(SV *const rv,
const char *nom de classe const,
const IV iv)

sv_setref_nv
Copie un double dans un nouveau SV, bénissant éventuellement le SV. L'argument "rv" sera
être surclassé en VR. Ce RV sera modifié pour pointer vers le nouveau SV. La
L'argument "classname" indique le package pour la bénédiction. Définissez "nom de classe" sur
"NULL" pour éviter la bénédiction. Le nouveau SV aura un nombre de références de 1, et
le RV sera retourné.

SV* sv_setref_nv(SV *const rv,
const char *nom de classe const,
const SA SA)

sv_setref_pv
Copie un pointeur dans un nouveau SV, bénissant éventuellement le SV. L'argument « rv »
sera transformé en VR. Ce RV sera modifié pour pointer vers le nouveau SV. Si
l'argument "pv" est NULL alors "PL_sv_undef" sera placé dans le SV. La
L'argument "classname" indique le package pour la bénédiction. Définissez "nom de classe" sur
"NULL" pour éviter la bénédiction. Le nouveau SV aura un nombre de références de 1, et
le RV sera retourné.

Ne pas utiliser avec d'autres types de Perl tels que HV, AV, SV, CV, car ces objets
sera corrompu par le processus de copie du pointeur.

Notez que "sv_setref_pvn" copie la chaîne tandis que this copie le pointeur.

SV* sv_setref_pv(SV *const rv,
const char *nom de classe const,
vide *const pv)

sv_setref_pvn
Copie une chaîne dans un nouveau SV, bénissant éventuellement le SV. La longueur du
chaîne doit être spécifiée avec "n". L'argument "rv" sera mis à niveau vers un RV.
Ce RV sera modifié pour pointer vers le nouveau SV. L'argument "nom de classe"
indique le paquet pour la bénédiction. Définissez "classname" sur "NULL" pour éviter le
bénédiction. Le nouveau SV aura un nombre de références de 1, et le RV sera
revenu.

Notez que "sv_setref_pv" copie le pointeur tandis que ceci copie la chaîne.

SV* sv_setref_pvn(SV *const rv,
const char *nom de classe const,
const car *const pv,
const STRLEN n)

sv_setref_pvs
Comme "sv_setref_pvn", mais prend une chaîne littérale au lieu d'une paire chaîne/longueur.

SV * sv_setref_pvs(const char* s)

sv_setref_uv
Copie un entier non signé dans un nouveau SV, bénissant éventuellement le SV. Le "RV"
sera mis à niveau vers un RV. Ce RV sera modifié pour pointer vers le nouveau
SV. L'argument "classname" indique le package pour la bénédiction. Régler
"classname" à "NULL" pour éviter la bénédiction. Le nouveau SV aura une référence
compter de 1, et le RV sera retourné.

SV* sv_setref_uv(SV *const rv,
const char *nom de classe const,
UV constant uv)

sv_setsv
Copie le contenu de la source SV "ssv" dans la destination SV "dsv". La
la source SV peut être détruite si elle est mortelle, donc n'utilisez pas cette fonction si le
la source SV doit être réutilisée. Ne gère pas la magie 'set' sur la destination SV.
Appelle 'get' magic sur la source SV. En gros, il effectue une copie par valeur,
effaçant tout contenu précédent de la destination.

Vous souhaitez probablement utiliser l'un des assortiments d'emballages, tels que "SvSetSV",
"SvSetSV_nosteal", "SvSetMagicSV" et "SvSetMagicSV_nosteal".

annuler sv_setsv(SV *dstr, SV *sstr)

sv_setsv_flags
Copie le contenu de la source SV "ssv" dans la destination SV "dsv". La
la source SV peut être détruite si elle est mortelle, donc n'utilisez pas cette fonction si le
la source SV doit être réutilisée. Ne gère pas la magie 'set'. En gros, il
effectue une copie par valeur, effaçant tout contenu précédent de la destination.
Si le paramètre "flags" a le bit "SV_GMAGIC" défini, "mg_get" sur "ssv" si
approprié, sinon non. Si le paramètre "flags" a le bit "SV_NOSTEAL" activé alors
les tampons d'intérim ne seront pas volés. et "sv_setsv_nomg" sont
implémenté dans le cadre de cette fonction.

Vous souhaitez probablement utiliser l'un des assortiments d'emballages, tels que "SvSetSV",
"SvSetSV_nosteal", "SvSetMagicSV" et "SvSetMagicSV_nosteal".

C'est la fonction principale pour copier des scalaires, et la plupart des autres copie-ish
les fonctions et les macros l'utilisent en dessous.

void sv_setsv_flags(SV *dstr, SV *sstr,
const drapeaux I32)

sv_setsv_mg
Comme "sv_setsv", mais gère également la magie 'set'.

void sv_setsv_mg(SV *const dstr, SV *const sstr)

sv_setuv
Copie un entier non signé dans le SV donné, en mettant d'abord à niveau si nécessaire. Fait
ne gère pas la magie 'set'. Voir aussi "sv_setuv_mg".

void sv_setuv(SV *const sv, const UV num)

sv_setuv_mg
Comme "sv_setuv", mais gère également la magie "set".

void sv_setuv_mg(SV *const sv, const UV u)

sv_tainted
Testez un SV pour la souillure. Utilisez "SvTAINTED" à la place.

bool sv_tainted(SV *const sv)

sv_true Renvoie vrai si le SV a une valeur vraie selon les règles de Perl. Utilisez la macro "SvTRUE"
à la place, qui peut appeler "sv_true()" ou peut utiliser à la place une version en ligne.

I32 sv_true(SV *const sv)

sv_unmagic
Supprime toutes les magies de type "type" d'un SV.

int sv_unmagic(SV *const sv, type const int)

sv_unmagicext
Supprime toutes les magies de type "type" avec le "vtbl" spécifié d'un SV.

int sv_unmagicext(SV *const sv, type const int,
MGVTBL *vtbl)

sv_unref_flags
Désactive l'état RV du SV et décrémente le nombre de références de tout ce qui était
étant référencé par le RV. Cela peut presque être considéré comme un renversement de
"nouveauSVrv". L'argument "cflags" peut contenir "SV_IMMEDIATE_UNREF" pour forcer le
nombre de références à décrémenter (sinon la décrémentation est conditionnelle à
le nombre de références étant différent de un ou la référence étant en lecture seule
SV). Voir "SvROK_off".

void sv_unref_flags (SV *const ref, const U32 drapeaux)

sv_untaint
Nettoyer un SV. Utilisez "SvTAINTED_off" à la place.

void sv_untaint(SV *const sv)

sv_upgrade
Mettez à niveau un SV vers un formulaire plus complexe. Ajoute généralement un nouveau type de corps au SV,
copie ensuite autant d'informations que possible à partir de l'ancien corps. Il croasse
si le SV est déjà sous une forme plus complexe que celle demandée. Vous voulez généralement
utiliser le wrapper de macro "SvUPGRADE", qui vérifie le type avant d'appeler
"sv_upgrade", et donc ne coasse pas. Voir aussi "svtype".

void sv_upgrade(SV *const sv, svtype new_type)

sv_usepvn_flags
Indique à un SV d'utiliser "ptr" pour trouver sa valeur de chaîne. Normalement, la chaîne est stockée
à l'intérieur du SV, mais sv_usepvn permet au SV d'utiliser une chaîne extérieure. Le "ptr"
doit pointer vers la mémoire qui a été allouée par Newx. Ce doit être le début d'une
Newx-ed bloc de mémoire, et non un pointeur au milieu de celui-ci (attention à OOK et
copie sur écriture), et ne pas provenir d'un répartiteur de mémoire non-Newx comme "malloc". La
longueur de chaîne, "len", doit être fournie. Par défaut, cette fonction "Renouveler"
(c'est-à-dire réallouer, déplacer) la mémoire pointée par "ptr", de sorte que le pointeur ne doit pas être
libéré ou utilisé par le programmeur après l'avoir donné à sv_usepvn, et ni l'un ni l'autre ne devrait
tous les pointeurs "derrière" ce pointeur (par exemple ptr + 1) doivent être utilisés.

Si "flags" & SV_SMAGIC est vrai, appellera SvSETMAGIC. Si "drapeaux" &
SV_HAS_TRAILING_NUL est vrai, alors "ptr[len]" doit être "NUL", et la réallocation sera
être ignoré (c'est-à-dire que le tampon est en fait au moins 1 octet plus long que "len", et
répond déjà aux exigences de stockage dans "SvPVX").

void sv_usepvn_flags(SV *const sv, char* ptr,
const STRLEN len,
drapeaux const U32)

sv_utf8_decode
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Si le PV du SV est une séquence d'octets en UTF-8 et contient un multiple-byte
caractère, le drapeau "SvUTF8" est activé pour qu'il ressemble à un caractère. Si
le PV ne contient que des caractères à un octet, le drapeau "SvUTF8" reste éteint. Numérisations
PV pour la validité et renvoie faux si le PV est invalide UTF-8.

booléen sv_utf8_decode(SV *const sv)

sv_utf8_downgrade
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Tente de convertir la PV d'un SV de caractères en octets. Si le PV contient
un caractère qui ne tient pas dans un octet, cette conversion échouera ; dans ce cas,
renvoie false ou, si "fail_ok" n'est pas vrai, croasse.

Il ne s'agit pas d'une interface d'encodage Unicode vers octet à usage général : utilisez l'option Encode
prolongation pour ça.

booléen sv_utf8_downgrade(SV *const sv,
const bool fail_ok)

sv_utf8_encode
Convertit le PV d'un SV en UTF-8, mais désactive ensuite le drapeau "SvUTF8" afin qu'il
ressemble à nouveau à des octets.

annuler sv_utf8_encode(SV *const sv)

sv_utf8_upgrade
Convertit le PV d'un SV en sa forme encodée en UTF-8. Force le SV à former une chaîne
si ce n'est déjà fait. Will "mg_get" sur "sv" le cas échéant. Définit toujours le
Drapeau SvUTF8 pour éviter les futurs contrôles de validité même si toute la chaîne est la même
en UTF-8 comme non. Renvoie le nombre d'octets dans la chaîne convertie

Il ne s'agit pas d'un codage d'octets à usage général vers l'interface Unicode : utilisez la commande Encode
prolongation pour ça.

STRLEN sv_utf8_upgrade(SV *sv)

sv_utf8_upgrade_flags
Convertit le PV d'un SV en sa forme encodée en UTF-8. Force le SV à former une chaîne
si ce n'est déjà fait. Définit toujours l'indicateur SvUTF8 pour éviter de futurs contrôles de validité
même si tous les octets sont invariants en UTF-8. Si "flags" a le bit "SV_GMAGIC" activé,
"mg_get" sur "sv" le cas échéant, sinon non.

Si "flags" a SV_FORCE_UTF8_UPGRADE défini, cette fonction suppose que le PV sera
se développer lors de la conversion en UTF-8, et évite le travail supplémentaire de vérification de cela.
Généralement, cet indicateur est utilisé par une routine qui a déjà analysé la chaîne et
trouvé de tels caractères, et transmet ces informations afin que le travail ne
doivent être répétés.

Renvoie le nombre d'octets dans la chaîne convertie.

Il ne s'agit pas d'un codage d'octets à usage général vers l'interface Unicode : utilisez la commande Encode
prolongation pour ça.

STRLEN sv_utf8_upgrade_flags(SV *const sv,
const drapeaux I32)

sv_utf8_upgrade_flags_grow
Comme sv_utf8_upgrade_flags, mais a un paramètre supplémentaire "extra", qui est le
nombre d'octets inutilisés que la chaîne de 'sv' est garantie d'avoir libre après
revenir. Cela permet à l'appelant de réserver un espace supplémentaire qu'il a l'intention de remplir, de
éviter les pousses supplémentaires.

"sv_utf8_upgrade", "sv_utf8_upgrade_nomg" et "sv_utf8_upgrade_flags" sont
implémenté dans le cadre de cette fonction.

Renvoie le nombre d'octets dans la chaîne convertie (sans compter les réserves).

STRLEN sv_utf8_upgrade_flags_grow(SV *const sv,
drapeaux const I32,
STRLEN supplémentaire)

sv_utf8_upgrade_nomg
Comme sv_utf8_upgrade, mais ne fait pas de magie sur "sv".

STRLEN sv_utf8_upgrade_nomg(SV *sv)

sv_vcatpvf
Traite ses arguments comme "vsprintf" et ajoute la sortie formatée à un SV.
Ne gère pas la magie 'set'. Voir "sv_vcatpvf_mg".

Généralement utilisé via son interface "sv_catpvf".

void sv_vcatpvf(SV *const sv, const car *const pat,
va_list *const arguments)

sv_vcatpvfn
void sv_vcatpvfn(SV *const sv, const car *const pat,
const STRLEN patlen,
va_list *const arguments,
SV **const svargs, const I32 svmax,
bool *const peut-être_contaminé)

sv_vcatpvfn_flags
Traite ses arguments comme "vsprintf" et ajoute la sortie formatée à un SV.
Utilise un tableau de SV si la liste d'arguments de la variable de style C est manquante (NULL).
Lors de l'exécution avec les contrôles de teinte activés, indique via "maybe_tainted" si les résultats
ne sont pas dignes de confiance (souvent en raison de l'utilisation de paramètres régionaux).

S'il est appelé en tant que "sv_vcatpvfn" ou si les drapeaux incluent "SV_GMAGIC", les appels deviennent magiques.

Généralement utilisé via l'une de ses interfaces "sv_vcatpvf" et "sv_vcatpvf_mg".

void sv_vcatpvfn_flags(SV *const sv,
const char *const pat,
const STRLEN patlen,
va_list *const arguments,
SV **const svargs,
const I32 svmax,
bool *const peut-être_contaminé,
drapeaux const U32)

sv_vcatpvf_mg
Comme "sv_vcatpvf", mais gère également la magie 'set'.

Habituellement utilisé via son interface "sv_catpvf_mg".

void sv_vcatpvf_mg(SV *const sv,
const char *const pat,
va_list *const arguments)

sv_vsetpvf
Fonctionne comme "sv_vcatpvf" mais copie le texte dans le SV au lieu de l'ajouter.
Ne gère pas la magie 'set'. Voir "sv_vsetpvf_mg".

Généralement utilisé via son interface "sv_setpvf".

void sv_vsetpvf(SV *const sv, const char *const pat,
va_list *const arguments)

sv_vsetpvfn
Fonctionne comme "sv_vcatpvfn" mais copie le texte dans le SV au lieu de l'ajouter.

Généralement utilisé via l'une de ses interfaces "sv_vsetpvf" et "sv_vsetpvf_mg".

void sv_vsetpvfn(SV *const sv, const car *const pat,
const STRLEN patlen,
va_list *const arguments,
SV **const svargs, const I32 svmax,
bool *const peut-être_contaminé)

sv_vsetpvf_mg
Comme "sv_vsetpvf", mais gère également la magie 'set'.

Habituellement utilisé via son interface "sv_setpvf_mg".

void sv_vsetpvf_mg(SV *const sv,
const char *const pat,
va_list *const arguments)

Unicode Assistance

"Unicode Support" dans perlguts a une introduction à cette API.

Voir aussi "Classification des caractères" et "Changement de casse des caractères". Diverses fonctions
en dehors de cette section fonctionnent également spécialement avec Unicode. Recherchez la chaîne "utf8" dans
ce document.

octets_cmp_utf8
Compare la séquence de caractères (stockés sous forme d'octets) dans "b", "blen" avec la
séquence de caractères (stockée en UTF-8) dans "u", "ulen". Renvoie 0 s'ils sont
égal, -1 ou -2 si la première chaîne est inférieure à la deuxième chaîne, +1 ou +2 si
la première chaîne est supérieure à la deuxième chaîne.

-1 ou +1 est renvoyé si la chaîne la plus courte était identique au début de la
chaîne plus longue. -2 ou +2 est renvoyé s'il y avait une différence entre les caractères
à l'intérieur des cordes.

int bytes_cmp_utf8(const U8 *b, STRLEN blen,
const U8 *u, STRLEN ulen)

octets_from_utf8
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Convertit une chaîne "s" de longueur "len" de UTF-8 en codage d'octet natif.
Contrairement à "utf8_to_bytes" mais comme "bytes_to_utf8", renvoie un pointeur vers le nouveau
chaîne créée et met à jour "len" pour contenir la nouvelle longueur. Renvoie l'original
chaîne si aucune conversion ne se produit, "len" est inchangé. Ne rien faire si "is_utf8"
pointe vers 0. Définit "is_utf8" sur 0 si "s" est converti ou composé entièrement de
caractères invariants en utf8 (c'est-à-dire US-ASCII sur des machines non EBCDIC).

U8* bytes_from_utf8(const U8 *s, STRLEN *len,
booléen *is_utf8)

octets_to_utf8
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Convertit une chaîne "s" de longueur "len" octets de l'encodage natif en UTF-8.
Renvoie un pointeur vers la chaîne nouvellement créée et définit "len" pour refléter le nouveau
longueur en octets.

Un caractère "NUL" sera écrit après la fin de la chaîne.

Si vous souhaitez convertir en UTF-8 à partir d'encodages autres que l'encodage natif (Latin1 ou
EBCDIC), voir "sv_recode_to_utf8"().

U8* bytes_to_utf8(const U8 *s, STRLEN *len)

DO_UTF8 Renvoie un booléen indiquant si oui ou non la PV dans "sv" doit être traitée comme étant
codé en UTF-8.

Tu devrais utiliser ça après un appel à "SvPV()" ou une de ses variantes, au cas où
l'appel à la surcharge de chaîne met à jour l'indicateur de codage UTF-8 interne.

booléen DO_UTF8(SV* sv)

plierEQ_utf8
Renvoie vrai si les premières parties des chaînes "s1" et "s2" (soit ou les deux
dont peut être en UTF-8) sont les mêmes sans tenir compte de la casse ; faux sinon. Comment
loin dans les chaînes à comparer est déterminé par d'autres paramètres d'entrée.

Si "u1" est vrai, la chaîne "s1" est supposée être en Unicode codé en UTF-8 ;
sinon, il est supposé être en codage natif 8 bits. De même pour "u2"
par rapport à "s2".

Si la longueur d'octet "l1" n'est pas nulle, il indique jusqu'où dans "s1" pour vérifier le pli
égalité. En d'autres termes, "s1"+"l1" sera utilisé comme objectif à atteindre. Le balayage
ne sera pas considéré comme un match à moins que l'objectif ne soit atteint, et le balayage
ne continuera pas au-delà de cet objectif. De même pour "l2" par rapport à "s2".

Si "pe1" n'est pas NULL et que le pointeur vers lequel il pointe n'est pas NULL, ce pointeur est
considéré comme un pointeur de fin vers la position 1 octet après le point maximum dans "s1"
au-delà de laquelle l'analyse ne se poursuivra en aucun cas. (Cette routine
suppose que les chaînes d'entrée encodées en UTF-8 ne sont pas mal formées ; entrée malformée peut
l'amener à lire au-delà de "pe1"). Cela signifie que si "l1" et "pe1" sont
spécifié et que "pe1" est inférieur à "s1"+"l1", la correspondance ne réussira jamais
parce qu'il ne peut jamais aller aussi loin que son but (et qu'il est en fait revendiqué contre).
De même pour "pe2" par rapport à "s2".

Au moins un de "s1" et "s2" doit avoir un objectif (au moins un de "l1" et "l2" doit
être différent de zéro), et si les deux le font, les deux doivent être atteints pour une correspondance réussie.
De plus, si le pli d'un caractère est composé de plusieurs caractères, tous doivent être
assorti (voir référence tr21 ci-dessous pour 'pliage').

En cas de correspondance réussie, si "pe1" n'est pas NULL, il sera défini pour pointer vers le
début de la next caractère de "s1" au-delà de ce qui correspondait. En conséquence
pour "pe2" et "s2".

Pour l'insensibilité à la casse, le "casefolding" d'Unicode est utilisé à la place de
majuscule/minuscule à la fois les caractères, voir
<http://www.unicode.org/unicode/reports/tr21/> (Mappages de cas).

I32 foldEQ_utf8(car const *s1, car **pe1, UV l1,
booléen u1, caractère const *s2, caractère **pe2,
UV l2, booléen u2)

estUTF8_CHAR
Renvoie le nombre d'octets commençant à "s" qui forment un UTF-8 légal (ou UTF-
EBCDIC) caractère codé, ne regardant pas plus loin que "e - s" octets dans "s".
Renvoie 0 si la séquence commençant de "s" à "e - 1" n'est pas bien formée UTF-8

Notez qu'un caractère INVARIANT (c'est-à-dire ASCII sur des machines non-EBCDIC) est un
Caractère UTF-8.

STRLEN estUTF8_CHAR(const U8 *s, const U8 *e)

is_ascii_string
Il s'agit d'un synonyme au nom trompeur de "is_invariant_string". Sur ASCII-ish
plates-formes, le nom n'est pas trompeur : les caractères de la plage ASCII sont exactement les
Invariants UTF-8. Mais les machines EBCDIC ont plus d'invariants que le simple ASCII
caractères, donc "is_invariant_string" est préféré.

bool is_ascii_string(const U8 *s, STRLEN len)

is_invariant_string
Renvoie true ssi les premiers octets "len" de la chaîne "s" sont les mêmes quel que soit
de l'encodage UTF-8 de la chaîne (ou de l'encodage UTF-EBCDIC sur les machines EBCDIC).
Autrement dit, s'ils sont invariants UTF-8. Sur les machines ASCII-ish, tous les ASCII
caractères et seuls les caractères ASCII correspondent à cette définition. Sur les machines EBCDIC,
les caractères de la plage ASCII sont invariants, mais il en va de même pour les commandes C1 et
"\ c ?" (qui n'est pas dans la plage ASCII sur EBCDIC).

Si "len" est 0, il sera calculé en utilisant strlen(s), (ce qui signifie que si vous utilisez ce
option, ce "s" ne peut pas avoir de caractères "NUL" intégrés et doit avoir un
octet "NUL" de fin).

Voir aussi "is_utf8_string"(), "is_utf8_string_loclen"(), et
"is_utf8_string_loc"().

bool is_invariant_string(const U8 *s, STRLEN len)

is_utf8_string
Renvoie true si les premiers octets "len" de la chaîne "s" forment une chaîne UTF-8 valide,
faux sinon. Si "len" est 0, il sera calculé en utilisant strlen(s) (qui
signifie que si vous utilisez cette option, "s" ne peut pas contenir de caractères "NUL" intégrés et
doit avoir un octet "NUL" de fin). Notez que tous les caractères étant ASCII
constituent 'une chaîne UTF-8 valide'.

Voir aussi "is_invariant_string"(), "is_utf8_string_loclen"(), et
"is_utf8_string_loc"().

bool is_utf8_string(const U8 *s, STRLEN len)

is_utf8_string_loc
Comme "is_utf8_string" mais stocke l'emplacement de l'échec (dans le cas de
"échec utf8ness") ou l'emplacement "s"+"len" (dans le cas de "succès utf8ness")
dans le "ep".

Voir aussi "is_utf8_string_loclen"() et "is_utf8_string"().

bool is_utf8_string_loc(const U8 *s, STRLEN len,
const U8 **ep)

is_utf8_string_loclen
Comme "is_utf8_string"() mais stocke l'emplacement de l'échec (dans le cas de
"échec utf8ness") ou l'emplacement "s"+"len" (dans le cas de "succès utf8ness")
dans le "ep", et le nombre de caractères encodés en UTF-8 dans le "el".

Voir aussi "is_utf8_string_loc"() et "is_utf8_string"().

bool is_utf8_string_loclen(const U8 *s, STRLEN len,
const U8 **ep, STRLEN *el)

pv_uni_display
Construire au scalaire "dsv" une version affichable de la chaîne "spv", longueur "len",
la version affichable ayant au plus "pvlim" octets (si elle est plus longue, le reste est
tronqué et "..." sera ajouté).

L'argument "flags" peut avoir UNI_DISPLAY_ISPRINT défini pour afficher estIMPRIMER()capable
caractères comme eux-mêmes, UNI_DISPLAY_BACKSLASH pour afficher le \\[nrfta\\] comme le
versions avec barre oblique inversée (comme '\n') (UNI_DISPLAY_BACKSLASH est préféré à
UNI_DISPLAY_ISPRINT pour \\). UNI_DISPLAY_QQ (et son alias UNI_DISPLAY_REGEX)
avoir à la fois UNI_DISPLAY_BACKSLASH et UNI_DISPLAY_ISPRINT activés.

Le pointeur vers le PV du "dsv" est renvoyé.

Voir aussi "sv_uni_display".

char* pv_uni_display(SV *dsv, const U8 *spv,
STRLEN len, STRLEN pvlim,
drapeaux UV)

sv_cat_decode
L'encodage est supposé être un objet Encode, le PV du ssv est supposé être
octets dans ce codage et décodage l'entrée commence à partir de la position qui (PV
+ *offset) pointé vers. Le dsv sera concaténé avec la chaîne UTF-8 décodée de
sv. Le décodage se terminera lorsque la chaîne tstr apparaîtra dans la sortie de décodage ou
l'entrée se termine sur le PV du ssv. La valeur que les points de décalage seront
modifié à la dernière position d'entrée sur le ssv.

Renvoie TRUE si le terminateur a été trouvé, sinon renvoie FALSE.

booléen sv_cat_decode(SV* dsv, SV *encodage, SV *ssv,
int *offset, char* tstr, int tlen)

sv_recode_to_utf8
L'encodage est supposé être un objet Encode, à l'entrée le PV du sv est
supposé être des octets dans cet encodage, et le sv sera converti en Unicode
(et UTF-8).

Si le sv est déjà UTF-8 (ou s'il n'est pas POK), ou si l'encodage n'est pas un
référence, rien n'est fait au sv. Si l'encodage n'est pas un "Encode::XS"
Objet d'encodage, de mauvaises choses se produiront. (Voir lib/encodage.pm et Encoder.)

La PV du sv est renvoyée.

char* sv_recode_to_utf8(SV* sv, SV *encodage)

sv_uni_display
Construire au scalaire "dsv" une version affichable du scalaire "sv", le
version affichable ayant au plus "pvlim" octets de long (si plus long, le reste est
tronqué et "..." sera ajouté).

L'argument "flags" est comme dans "pv_uni_display"().

Le pointeur vers le PV du "dsv" est renvoyé.

char* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim,
drapeaux UV)

to_utf8_case
"p" contient le pointeur vers la chaîne UTF-8 codant le caractère qui est
converti. Cette routine suppose que le caractère à "p" est bien formé.

"ustrp" est un pointeur vers le tampon de caractères dans lequel placer le résultat de la conversion.
"lenp" est un pointeur sur la longueur du résultat.

"swashp" est un pointeur vers le swash à utiliser.

Les mappages spéciaux et normaux sont stockés dans lib/unicore/To/Foo.plet la bien-aimée Sonate en la majeur
chargé par SWASHNEW, en utilisant lib/utf8_heavy.pl. "spécial" (habituellement, mais pas toujours,
un mappage multicaractère), est essayé en premier.

"special" est une chaîne, normalement "NULL" ou "". "NULL" signifie ne pas utiliser d'éléments spéciaux
mappages ; "" signifie utiliser les mappages spéciaux. Les valeurs autres que ces deux sont
traité comme le nom du hachage contenant les mappages spéciaux, comme
"utf8::ToSpecLower".

"normal" est une chaîne comme "ToLower" qui signifie le swash %utf8::ToLower.

UV to_utf8_case(const U8 *p, U8* ustrp,
STRLEN *lenp, SV **swashp,
caractère const * normal,
caractère const *spécial)

to_utf8_fold
Utilisez plutôt "toFOLD_utf8".

UV to_utf8_fold(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_lower
Utilisez plutôt "toLOWER_utf8".

UV to_utf8_lower(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_title
Utilisez plutôt "toTITLE_utf8".

UV to_utf8_title(const U8 *p, U8* ustrp,
STRLEN *lenp)

to_utf8_upper
Utilisez plutôt "toUPPER_utf8".

UV to_utf8_upper(const U8 *p, U8* ustrp,
STRLEN *lenp)

utf8n_to_uvchr
CETTE FONCTION NE DOIT ÊTRE UTILISÉE QUE DANS DES CIRCONSTANCES TRÈS SPÉCIALISÉES. La plupart des codes
devrait utiliser "utf8_to_uvchr_buf"() plutôt que de l'appeler directement.

Routine de décodage UTF-8 de niveau inférieur. Renvoie la valeur du point de code natif du
premier caractère de la chaîne "s", supposée être en UTF-8 (ou UTF-EBCDIC)
encodage, et pas plus de "curlen" octets ; *retlen (si "retlen" n'est pas NULL)
être défini sur la longueur, en octets, de ce caractère.

La valeur de "flags" détermine le comportement lorsque "s" ne pointe pas vers un puits.
caractère UTF-8 formé. Si "flags" vaut 0, lorsqu'une malformation est détectée, zéro vaut
renvoyé et *retlen est défini de sorte que ("s" + *retlen) soit la prochaine position possible
en "s" qui pourrait commencer un caractère non malformé. De plus, si les avertissements UTF-8
n'ont pas été désactivés lexicalement, un avertissement est émis.

Divers drapeaux ALLOW peuvent être définis dans "flags" pour autoriser (et non avertir)
types de malformations, comme la séquence trop longue (c'est-à-dire lorsqu'il y a
est une séquence plus courte pouvant exprimer le même point de code ; les séquences trop longues sont
expressément interdit dans la norme UTF-8 en raison de problèmes de sécurité potentiels).
Un autre exemple de malformation est le premier octet d'un caractère qui n'est pas légal
premier octet. Voir utf8.h pour la liste de ces drapeaux. Pour les chaînes de longueur 0 autorisées,
cette fonction renvoie 0 ; pour les séquences trop longues autorisées, le point de code calculé
est retourné ; pour toutes les autres malformations autorisées, le REMPLACEMENT Unicode
CHARACTER est renvoyé, car ceux-ci n'ont pas de valeur raisonnable déterminable.

Le drapeau UTF8_CHECK_ONLY remplace le comportement lorsqu'un non-autorisé (par d'autres
flags) une malformation est retrouvée. Si cet indicateur est défini, la routine suppose que le
l'appelant déclenchera un avertissement, et cette fonction réglera silencieusement "retlen" sur
"-1" (converti en "STRLEN") et renvoie zéro.

Notez que cette API nécessite une désambiguïsation entre un décodage réussi d'un "NUL"
caractère et un retour d'erreur (sauf si l'indicateur UTF8_CHECK_ONLY est défini), comme dans
dans les deux cas, 0 est renvoyé. Pour lever l'ambiguïté, sur un retour nul, voir si le premier
l'octet de "s" vaut également 0. Si c'est le cas, l'entrée était un "NUL" ; sinon, l'entrée avait un
Erreur.

Certains points de code sont considérés comme problématiques. Ce sont des substituts Unicode,
Non-caractères Unicode et points de code au-dessus du maximum Unicode de 0x10FFFF. Par
par défaut, ceux-ci sont considérés comme des points de code réguliers, mais certaines situations justifient
un traitement spécial pour eux. Si "flags" contient UTF8_DISALLOW_ILLEGAL_INTERCHANGE,
les trois classes sont traitées comme des malformations et traitées comme telles. Les drapeaux
UTF8_DISALLOW_SURROGATE, UTF8_DISALLOW_NONCHAR et UTF8_DISALLOW_SUPER (signifiant
au-dessus du maximum légal Unicode) peut être défini pour interdire ces catégories
individuellement.

Les drapeaux UTF8_WARN_ILLEGAL_INTERCHANGE, UTF8_WARN_SURROGATE, UTF8_WARN_NONCHAR,
et UTF8_WARN_SUPER provoqueront l'émission de messages d'avertissement pour leurs
catégories, mais sinon les points de code sont considérés comme valides (pas
malformations). Pour qu'une catégorie soit à la fois traitée comme une malformation et qu'elle augmente
un avertissement, spécifiez à la fois les indicateurs WARN et DISALLOW. (Mais notez que les avertissements sont
non déclenché si lexicalement désactivé ni si UTF8_CHECK_ONLY est également spécifié.)

Les points de code très volumineux (au-dessus de 0x7FFF_FFFF) sont considérés comme plus problématiques que
les autres qui sont au-dessus du maximum légal Unicode. Il existe plusieurs raisons:
ils nécessitent au moins 32 bits pour les représenter sur les plates-formes ASCII, ne sont pas
représentable du tout sur les plates-formes EBCDIC, et la spécification UTF-8 d'origine
n'a jamais dépassé ce nombre (la limite actuelle de 0x10FFFF a été imposée plus tard). (La
les plus petits, ceux qui tiennent en 32 bits, sont représentables par un UV sur ASCII
plates-formes, mais pas par un IV, ce qui signifie que le nombre d'opérations qui peuvent être
exécuté sur eux est assez limité.) Le codage UTF-8 sur les plates-formes ASCII pour
ces grands points de code commencent par un octet contenant 0xFE ou 0xFF. La
Le drapeau UTF8_DISALLOW_FE_FF les fera traiter comme des malformations, tandis que
permettant des points de code supérieurs à Unicode plus petits. (Bien sûr UTF8_DISALLOW_SUPER sera
traiter tous les points de code Unicode ci-dessus, y compris ceux-ci, comme des malformations.)
De même, UTF8_WARN_FE_FF agit comme les autres drapeaux WARN, mais s'applique uniquement
à ces points de code.

Tous les autres points de code correspondant aux caractères Unicode, y compris à usage privé
et ceux qui n'ont pas encore été attribués, ne sont jamais considérés comme malformés et ne préviennent jamais.

UV utf8n_to_uvchr(const U8 *s, STRLEN curlen,
STRLEN *retlen, drapeaux U32)

utf8n_to_uvuni
Utilisez plutôt "utf8_to_uvchr_buf", ou rarement, "utf8n_to_uvchr".

Cette fonction était utile pour le code qui voulait gérer à la fois EBCDIC et ASCII
plates-formes avec des propriétés Unicode, mais à partir de Perl v5.20, les distinctions
entre les plates-formes ont pour la plupart été rendues invisibles pour la plupart des codes, donc cela
il est peu probable que la fonction corresponde à ce que vous voulez. Si vous avez besoin de cette précision
fonctionnalité, utilisez plutôt "NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" ou
"NATIVE_TO_UNI(utf8n_to_uvchr(...))".

UV utf8n_to_uvuni(const U8 *s, STRLEN curlen,
STRLEN *retlen, drapeaux U32)

UTF8SAUTER
renvoie le nombre d'octets dans le caractère encodé en UTF-8 dont le premier (peut-être
uniquement) l'octet est pointé par "s".

STRLEN UTF8SKIP(car* s)

utf8_distance
Renvoie le nombre de caractères UTF-8 entre les pointeurs UTF-8 "a" et "b".

AVERTISSEMENT : à utiliser uniquement si vous *savez* que les pointeurs pointent à l'intérieur du même UTF-8
un tampon.

IV utf8_distance(const U8 *a, const U8 *b)

utf8_hop
Renvoie le pointeur UTF-8 "s" déplacé par des caractères "off", soit vers l'avant, soit
en arrière.

AVERTISSEMENT : n'utilisez pas ce qui suit à moins que vous *saviez* que "off" se trouve dans les données UTF-8
pointé par "s" *et* que sur l'entrée "s" est aligné sur le premier octet de
caractère ou juste après le dernier octet d'un caractère.

U8* utf8_hop(const U8 *s, I32 désactivé)

utf8_longueur
Renvoie la longueur de la chaîne encodée en caractères UTF-8 "s" en caractères. Arrête à
"e" (inclusif). Si "e < s" ou si le scan se termine par "e", croasse.

STRLEN utf8_length(const U8* s, const U8 *e)

utf8_to_bytes
REMARQUE : cette fonction est expérimentale et peut être modifiée ou supprimée sans préavis.

Convertit une chaîne "s" de longueur "len" de UTF-8 en codage d'octet natif.
Contrairement à "bytes_to_utf8", cela écrase la chaîne d'origine et met à jour "len" en
contenir la nouvelle longueur. Renvoie zéro en cas d'échec, en définissant "len" sur -1.

Si vous avez besoin d'une copie de la chaîne, consultez "bytes_from_utf8".

U8* utf8_to_bytes(U8 *s, STRLEN *len)

utf8_to_uvchr_buf
Renvoie le point de code natif du premier caractère de la chaîne "s" qui est
supposé être en codage UTF-8 ; "send" pointe vers 1 au-delà de la fin de "s".
*retlen sera défini sur la longueur, en octets, de ce caractère.

Si "s" ne pointe pas vers un caractère UTF-8 bien formé et que des avertissements UTF8 sont
activé, zéro est renvoyé et *retlen est défini (si "retlen" n'est pas NULL) sur -1. Si
ces avertissements sont désactivés, la valeur calculée, si elle est bien définie (ou l'Unicode
Si ce n'est pas le cas, CARACTÈRE DE REMPLACEMENT), est renvoyé silencieusement et *retlen est défini (si
"retlen" n'est pas NULL) de sorte que ("s" + *retlen) est la prochaine position possible dans "s"
qui pourrait commencer un personnage non malformé. Voir "utf8n_to_uvchr" pour plus de détails sur
lorsque le CARACTÈRE DE REMPLACEMENT est renvoyé.

UV utf8_to_uvchr_buf(const U8 *s, const U8 *envoyer,
STRLEN *retlen)

utf8_to_uvuni_buf
DÉCONSEILLÉ ! Il est prévu de supprimer cette fonction d'une future version de Perl.
Ne l'utilisez pas pour un nouveau code ; le supprimer du code existant.

Ce n'est que dans de très rares circonstances que le code doit être traité en Unicode (comme
par opposition aux points de code natifs). Dans ces quelques cas, utilisez
"NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" à la place.

Renvoie le point de code Unicode (non natif) du premier caractère de la chaîne
"s" qui est supposé être en codage UTF-8 ; "envoyer" pointe vers 1 au-delà de la fin de
"s". "retlen" sera défini sur la longueur, en octets, de ce caractère.

Si "s" ne pointe pas vers un caractère UTF-8 bien formé et que des avertissements UTF8 sont
activé, zéro est renvoyé et *retlen est défini (si "retlen" n'est pas NULL) sur -1. Si
ces avertissements sont désactivés, la valeur calculée si elle est bien définie (ou l'Unicode
CARACTÈRE DE REMPLACEMENT, si ce n'est pas le cas) est renvoyé silencieusement et *retlen est défini (si
"retlen" n'est pas NULL) de sorte que ("s" + *retlen) est la prochaine position possible dans "s"
qui pourrait commencer un personnage non malformé. Voir "utf8n_to_uvchr" pour plus de détails sur
lorsque le CARACTÈRE DE REMPLACEMENT est renvoyé.

UV utf8_to_uvuni_buf(const U8 *s, const U8 *envoyer,
STRLEN *retlen)

UVCHR_SKIP
renvoie le nombre d'octets requis pour représenter le point de code "cp" lorsqu'il est encodé
comme UTF-8. "cp" est un point de code natif (ASCII ou EBCDIC) s'il est inférieur à 255 ; un
Point de code Unicode sinon.

STRLEN UVCHR_SKIP(UVcp)

uvchr_to_utf8
Ajoute la représentation UTF-8 du point de code natif "uv" à la fin du
chaîne "d" ; "d" doit avoir au moins "UVCHR_SKIP(uv)+1" (jusqu'à "UTF8_MAXBYTES+1")
octets gratuits disponibles. La valeur de retour est le pointeur sur l'octet après la fin
du nouveau personnage. Autrement dit,

d = uvchr_to_utf8(d,uv);

est la façon recommandée de dire, compatible avec les caractères natifs,

*(d++) = uv ;

Cette fonction accepte n'importe quel UV en entrée. Pour interdire ou avertir sur du code non Unicode
points, ou ceux qui peuvent être problématiques, voir "uvchr_to_utf8_flags".

U8* uvchr_to_utf8(U8 *d, UVuv)

uvchr_to_utf8_flags
Ajoute la représentation UTF-8 du point de code natif "uv" à la fin du
chaîne "d" ; "d" doit avoir au moins "UVCHR_SKIP(uv)+1" (jusqu'à "UTF8_MAXBYTES+1")
octets gratuits disponibles. La valeur de retour est le pointeur sur l'octet après la fin
du nouveau personnage. Autrement dit,

d = uvchr_to_utf8_flags(d, uv, drapeaux);

ou, dans la plupart des cas,

d = uvchr_to_utf8_flags(d, uv, 0);

C'est la façon compatible Unicode de dire

*(d++) = uv ;

Cette fonction convertira en UTF-8 (et non avertira) même les points de code qui ne sont pas
Unicode légal ou sont problématiques, à moins que "flags" ne contienne un ou plusieurs des
drapeaux suivants :

Si "uv" est un point de code de substitution Unicode et que UNICODE_WARN_SURROGATE est défini, le
déclenchera un avertissement, à condition que les avertissements UTF8 soient activés. Si à la place
UNICODE_DISALLOW_SURROGATE est défini, la fonction échouera et renverra NULL. Si
les deux drapeaux sont définis, la fonction avertira et renverra NULL.

Les indicateurs UNICODE_WARN_NONCHAR et UNICODE_DISALLOW_NONCHAR affectent la façon dont le
La fonction gère un non-caractère Unicode. Et de même, le UNICODE_WARN_SUPER
et les drapeaux UNICODE_DISALLOW_SUPER affectent la gestion des points de code qui sont au-dessus
le maximum Unicode de 0x10FFFF. Les points de code au-dessus de 0x7FFF_FFFF (qui sont pairs
moins portable) peut être averti et/ou refusé même si un autre code Unicode ci-dessus
les points sont acceptés, par les flags UNICODE_WARN_FE_FF et UNICODE_DISALLOW_FE_FF.

Et enfin, le drapeau UNICODE_WARN_ILLEGAL_INTERCHANGE sélectionne les quatre
au-dessus des drapeaux WARN ; et UNICODE_DISALLOW_ILLEGAL_INTERCHANGE sélectionne les quatre
NON AUTORISER les drapeaux.

U8* uvchr_to_utf8_flags(U8 *d, UV uv, drapeaux UV)

uvoffuni_to_utf8_flags
CETTE FONCTION NE DOIT ÊTRE UTILISÉE QUE DANS DES CIRCONSTANCES TRÈS SPÉCIALISÉES. À la place,
Presque tous code devrait utilisé "uvchr_to_utf8" or "uvchr_to_utf8_flags".

Cette fonction leur ressemble, mais l'entrée est un Unicode strict (par opposition à
point de code natif). Ce n'est que dans de très rares circonstances que le code ne doit pas utiliser le
point de code natif.

Pour plus de détails, voir la description de "uvchr_to_utf8_flags".

U8* uvoffuni_to_utf8_flags(U8 *d, UV uv, drapeaux UV)

uvuni_to_utf8_flags
Au lieu de cela, vous voudrez presque certainement utiliser "uvchr_to_utf8" ou "uvchr_to_utf8_flags".

Cette fonction est un synonyme obsolète de "uvoffuni_to_utf8_flags", qui lui-même,
bien qu'il ne soit pas obsolète, il ne doit être utilisé que dans des circonstances isolées. Ces
les fonctions étaient utiles pour le code qui voulait gérer à la fois EBCDIC et ASCII
plates-formes avec des propriétés Unicode, mais à partir de Perl v5.20, les distinctions
entre les plates-formes ont pour la plupart été rendues invisibles pour la plupart des codes, donc cela
il est peu probable que la fonction corresponde à ce que vous voulez.

U8* uvuni_to_utf8_flags(U8 *d, UV uv, drapeaux UV)

Variables créée by "xsubpp" et "xsubpp" interne fonctions

nouveauXSproto
Utilisé par "xsubpp" pour connecter les XSUB en tant que sous-marins Perl. Ajoute des prototypes Perl aux sous-marins.

XS_APIVERSION_BOOTCHECK
Macro pour vérifier que la version perl api d'un module XS a été compilée
correspond à la version api de l'interpréteur perl dans lequel il est chargé.

XS_APIVERSION_BOOTCHECK ;

XS_VERSION
L'identifiant de version d'un module XS. Ceci est généralement géré automatiquement par
"ExtUtils :: MakeMaker". Voir "XS_VERSION_BOOTCHECK".

XS_VERSION_BOOTCHECK
Macro pour vérifier que la variable $VERSION d'un module PM correspond à celle du module XS
Variable "XS_VERSION". Ceci est généralement géré automatiquement par "xsubpp". Voir
"The VERSIONCHECK: Keyword" dans perlxs.

XS_VERSION_BOOTCHECK ;

Versioning

nouvelle version
Renvoie un nouvel objet de version basé sur le SV transmis :

SV *sv = nouvelle_version(SV *ver);

Ne modifie pas le passé en ver SV. Voir "upg_version" si vous souhaitez mettre à jour le
SV.

SV* nouvelle_version(SV *ver)

version_préscan
Valide qu'une chaîne donnée peut être analysée en tant qu'objet de version, mais ne le fait pas
effectuer réellement l'analyse. Peut utiliser des règles de validation strictes ou laxistes. Boîte
définissez éventuellement un certain nombre de variables d'indice pour enregistrer le code d'analyse quelque temps lorsque
tokenisation.

const char* prescan_version(const char *s, bool strict,
const char** errstr,
bool * sqv,
int *ssaw_decimal,
int *swidth, booléen *salpha)

version_scan
Renvoie également un pointeur vers le caractère suivant après la chaîne de version analysée
comme la mise à niveau du passé en SV vers un RV.

La fonction doit être appelée avec un SV déjà existant comme

v = nouveauSV(0);
s = scan_version(s, SV *sv, bool qv);

Effectue un prétraitement de la chaîne pour s'assurer qu'elle a le bon
caractéristiques d'une version. Marque l'objet s'il contient un trait de soulignement
(ce qui signifie qu'il s'agit d'une version alpha). Le booléen qv indique que la version
doit être interprété comme s'il avait plusieurs décimales, même si ce n'est pas le cas.

const char* scan_version(const char *s, SV *rv, bool qv)

upg_version
Mise à niveau sur place de la SV fournie vers un objet de version.

SV *sv = upg_version(SV *sv, bool qv);

Renvoie un pointeur vers la SV mise à jour. Définissez le booléen qv si vous souhaitez forcer
cette SV doit être interprétée comme une version "étendue".

SV* upg_version(SV *ver, booléen qv)

vcmp Conscient de l'objet de version cmp. Les deux opérandes doivent déjà avoir été convertis en
objets de version.

entier vcmp(SV *lhv, SV *rhv)

vnormal Accepte un objet de version et renvoie la représentation sous forme de chaîne normalisée. Appel
comme:

sv = vnormal(rv);

REMARQUE : vous pouvez passer directement l'objet ou le SV contenu dans le RV.

Le SV retourné a un refcount de 1.

SV* vnormal(SV *vs)

vnumify Accepte un objet de version et renvoie la représentation en virgule flottante normalisée.
Appelez comme :

sv = vnumify(rv);

REMARQUE : vous pouvez passer directement l'objet ou le SV contenu dans le RV.

Le SV retourné a un refcount de 1.

SV* vnumifier(SV *vs)

vstringifier
Afin de maintenir une compatibilité maximale avec les versions antérieures de Perl, cette
renverra soit la notation à virgule flottante, soit les points multiples
notation, selon que la version originale contenait 1 ou plusieurs points,
respectivement.

Le SV retourné a un refcount de 1.

SV* vstringifier(SV *vs)

vverify Valide que la SV contient une structure interne valide pour un objet de version. Ce
peut être transmis soit l'objet version (RV) soit le hachage lui-même (HV). Si la
structure est valide, elle renvoie le HV. Si la structure n'est pas valide, elle renvoie
NUL.

SV *hv = vvérifier(sv);

Notez qu'il ne fait que confirmer la structure minimale (afin de ne pas confondre
par des classes dérivées pouvant contenir des entrées de hachage supplémentaires) :

SV* vvérifier(SV *vs)

Avertissement et Mourir

croak C'est une interface XS pour la fonction "die" de Perl.

Prenez un modèle de format de style sprintf et une liste d'arguments. Ceux-ci sont utilisés pour générer
un message de chaîne. Si le message ne se termine pas par une nouvelle ligne, il sera
étendu avec une indication de l'emplacement actuel dans le code, comme décrit
pour "mess_sv".

Le message d'erreur sera utilisé comme une exception, en rendant par défaut le contrôle à
le "eval" englobant le plus proche, mais sujet à modification par un $SIG{__DIE__}
gestionnaire. Dans tous les cas, la fonction "croak" ne revient jamais normalement.

Pour des raisons historiques, si "pat" est nul alors le contenu de "ERRSV" ($@) sera
utilisé comme message d'erreur ou objet au lieu de créer un message d'erreur à partir de
arguments. Si vous souhaitez lancer un objet non-chaîne ou créer un message d'erreur dans
un SV vous-même, il est préférable d'utiliser la fonction "croak_sv", qui ne
impliquent d'écraser "ERRSV".

void croak(const char *pat, ...)

croak_no_modify
Exactement équivalent à "Perl_croak(aTHX_ "%s", PL_no_modify)", mais génère terser
code objet que d'utiliser "Perl_croak". Moins de code utilisé sur les chemins de code d'exception
réduit la pression du cache CPU.

annuler croak_no_modify()

coasser_sv
Il s'agit d'une interface XS pour la fonction "die" de Perl.

"baseex" est le message d'erreur ou l'objet. S'il s'agit d'une référence, elle sera utilisée
comme si. Sinon, il est utilisé comme une chaîne, et s'il ne se termine pas par une nouvelle ligne
puis il sera étendu avec une indication de l'emplacement actuel dans le code,
comme décrit pour "mess_sv".

Le message d'erreur ou l'objet sera utilisé comme une exception, renvoyant par défaut
contrôle au plus proche « eval » englobant, mais sujet à modification par un
Gestionnaire $SIG{__DIE__}. Dans tous les cas, la fonction "croak_sv" ne retourne jamais
normalement.

Pour mourir avec une simple chaîne de message, la fonction "croak" peut être plus pratique.

void croak_sv(SV *baseex)

die Se comporte comme "croak", sauf pour le type de retour. Il doit être utilisé uniquement
où le type de retour "OP *" est requis. La fonction ne revient jamais réellement.

OP * die(const char *pat, ...)

die_sv Se comporte comme "croak_sv", sauf pour le type de retour. Il devrait être utilisé
uniquement lorsque le type de retour "OP *" est requis. La fonction n'a jamais réellement
résultats.

OP * die_sv(SV *baseex)

vcroak C'est une interface XS pour la fonction "die" de Perl.

"pat" et "args" sont un modèle de format de style sprintf et un argument encapsulé
liste. Ceux-ci sont utilisés pour générer un message de chaîne. Si le message ne se termine pas
avec une nouvelle ligne, puis il sera étendu avec une indication du courant
emplacement dans le code, comme décrit pour "mess_sv".

Le message d'erreur sera utilisé comme une exception, en rendant par défaut le contrôle à
le "eval" englobant le plus proche, mais sujet à modification par un $SIG{__DIE__}
gestionnaire. Dans tous les cas, la fonction "croak" ne revient jamais normalement.

Pour des raisons historiques, si "pat" est nul alors le contenu de "ERRSV" ($@) sera
utilisé comme message d'erreur ou objet au lieu de créer un message d'erreur à partir de
arguments. Si vous souhaitez lancer un objet non-chaîne ou créer un message d'erreur dans
un SV vous-même, il est préférable d'utiliser la fonction "croak_sv", qui ne
impliquent d'écraser "ERRSV".

void vcroak(const char *pat, va_list *args)

vwarn C'est une interface XS pour la fonction "warn" de Perl.

"pat" et "args" sont un modèle de format de style sprintf et un argument encapsulé
liste. Ceux-ci sont utilisés pour générer un message de chaîne. Si le message ne se termine pas
avec une nouvelle ligne, puis il sera étendu avec une indication du courant
emplacement dans le code, comme décrit pour "mess_sv".

Le message d'erreur ou l'objet sera écrit par défaut sur l'erreur standard, mais cela
est sujet à modification par un gestionnaire $SIG{__WARN__}.

Contrairement à "vcroak", "pat" n'est pas autorisé à être nul.

void vwarn(const char *pat, va_list *args)

warn C'est une interface XS pour la fonction "warn" de Perl.

Prenez un modèle de format de style sprintf et une liste d'arguments. Ceux-ci sont utilisés pour générer
un message de chaîne. Si le message ne se termine pas par une nouvelle ligne, il sera
étendu avec une indication de l'emplacement actuel dans le code, comme décrit
pour "mess_sv".

Le message d'erreur ou l'objet sera écrit par défaut sur l'erreur standard, mais cela
est sujet à modification par un gestionnaire $SIG{__WARN__}.

Contrairement à "croak", "pat" n'est pas autorisé à être nul.

void warn(const char *pat, ...)

warn_sv C'est une interface XS pour la fonction "warn" de Perl.

"baseex" est le message d'erreur ou l'objet. S'il s'agit d'une référence, elle sera utilisée
comme si. Sinon, il est utilisé comme une chaîne, et s'il ne se termine pas par une nouvelle ligne
puis il sera étendu avec une indication de l'emplacement actuel dans le code,
comme décrit pour "mess_sv".

Le message d'erreur ou l'objet sera écrit par défaut sur l'erreur standard, mais cela
est sujet à modification par un gestionnaire $SIG{__WARN__}.

Pour avertir avec une simple chaîne de message, la fonction "warn" peut être plus pratique.

void warn_sv(SV *baseex)

Sans-papiers fonctions

Les fonctions suivantes ont été signalées dans le cadre de l'API publique, mais sont actuellement
sans papiers. Utilisez-les à vos risques et périls, car les interfaces sont susceptibles de changer.
Les fonctions qui ne sont pas répertoriées dans ce document ne sont pas destinées à un usage public et doivent
NE PAS être utilisé en aucune circonstance.

Si vous utilisez l'une des fonctions non documentées ci-dessous, vous pouvez envisager de créer et
en soumettant la documentation correspondante. Si votre patch est accepté, cela indiquera que le
l'interface est stable (sauf indication contraire explicite).

ObtenirVars
Gv_AMupdate
PerlIO_clearerr
PerlIO_close
PerlIO_context_layers
PerlIO_eof
PerlIO_erreur
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 lu
PerlIO_write
appel_magique
amagic_deref_call
any_dup
atfork_lock
atfork_unlock
av_arylen_p
av_iter_p
bloc_donne-moi
appel_atexit
liste_d'appels
callo
cast_i32
casting_iv
cast_ulong
cast_uv
ck_warner
ck_warner_d
avertir
ckwar_d
clone_params_del
clone_params_new
croak_memory_wrap
croak_nocontext
csighhandler
cx_dump
cx_dup
cxinc
deb
deb_nocontext
debop
debprofdump
débstack
débstackptrs
délictueux
signaux d'expédition
die_nocontext
dirp_dup
faire_aspawn
do_binmode
faire_fermer
do_gv_dump
do_gvgv_dump
do_hv_dump
faire_joindre
do_magic_dump
do_op_dump
faire_ouvrir
faire_open9
do_openn
do_pmop_dump
faire_spawn
do_spawn_nowait
faire_sprintf
do_sv_dump
faire_taint
doref
se détendre
dowantarray
dump_eval
dump_form
dump_indent
dump_mstats
dump_sub
dump_vindent
filtre_ajouter
filtre_del
filtre_read
plierEQ_latin1
formulaire_nocontext
fp_dup
fprintf_nocontext
free_global_struct
libre_tmps
get_context
get_mstats
get_op_descs
get_op_names
get_ppaddr
get_vtbl
gp_dup
gp_free
gp_ref
gv_AVadd
gv_HVadd
gv_IOadd
gv_SVadd
gv_add_by_type
gv_autoload4
gv_autoload_pv
gv_autoload_pvn
gv_autoload_sv
gv_check
gv_dump
gv_enomcomplet
gv_efullname3
gv_efullname4
gv_fetchfile
gv_fetchfile_flags
gv_fetchpv
gv_fetchpvn_flags
gv_fetchsv
gv_nom complet
gv_nomcomplet3
gv_nomcomplet4
gv_handler
gv_name_set
il_dup
hek_dup
hv_common
hv_common_key_len
hv_delayfree_ent
hv_eiter_p
hv_eiter_set
hv_free_ent
hv_ksplit
hv_name_set
hv_placeholders_get
hv_placeholders_set
hv_rand_set
hv_riter_p
hv_riter_set
ibcmp_utf8
init_global_struct
init_stacks
init_tm
instr
est_lvalue_sub
quitter_scope
load_module_nocontext
dump_magique
malloc
markstack_grow
mess_nocontext
gratuit
mg_dup
mg_taille
mini_mktime
plus de commutateurs
mro_get_from_name
mro_get_private_data
mro_set_mro
mro_set_private_data
mon_atof
mon_atof2
ma_bcopie
mon_bzero
ma_chsize
mon_cxt_index
mon_cxt_init
mon_dirfd
ma_sortie
mon_échec_sortie
mon_fflush_all
ma_fourchette
mon_lstat
mon_memcmp
mon_memset
mon_pclose
mon_popen
ma_popen_list
mon_setenv
ma_paire_socket
ma_stat
mon_strftime
nouveauANONATTRSUB
nouveauANONHASH
nouveauANONLIST
nouveauANONSUB
nouveauATTRSUB
nouveauAVREF
nouveauCVREF
nouvelle forme
nouveauGVREF
nouveauGVgen
nouveauGVgen_flags
nouveauHVREF
nouveauHVhv
nouveauIO
nouveauMYSUB
nouveauPROG
nouveauRV
nouveauSUB
nouveauSVREF
nouveauSVpvf_nocontext
new_stackinfo
nistr
op_refcnt_lock
op_refcnt_unlock
analyseur_dup
perl_alloc_using
perl_clone_using
pmop_dump
pop_scope
prégcomp
prégexec
sans grossesse
enceinte2
printf_nocontext
ptr_table_fetch
ptr_table_free
ptr_table_new
ptr_table_split
ptr_table_store
push_scope
re_compiler
re_dup_guts
re_intuit_start
re_intuit_string
réallouer
reentrant_free
réentrant_init
réentrant_retry
taille_réentrante
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
regnext
répéter
rninstr
signal
rsignal_state
runops_debug
runops_standard
rvpv_dup
sécuritésyscalloc
système de sécurité gratuit
système de sécurité
safesysrealloc
save_I16
save_I32
save_I8
save_adelete
save_aelem
save_aelem_flags
save_alloc
save_aptr
save_ary
save_bool
save_clearsv
enregistrer_supprimer
save_destructeur
save_destructor_x
save_freeop
save_freepv
save_freesv
save_generic_pvref
save_generic_svref
save_gp
save_hash
save_hdelete
save_helem
save_helem_flags
save_hints
save_hptr
save_int
save_item
sauvegarder_iv
liste_de sauvegarde
save_long
save_mortalizesv
save_nogv
save_op
save_padsv_and_mortalize
save_pptr
save_pushi32ptr
save_pushtr
save_pushptrptr
save_re_context
save_scalar
save_set_svflags
save_shared_pvref
save_sptr
save_svref
save_vptr
savestack_grow
savestack_grow_cnt
num_scan
scan_vstring
seed
set_context
set_numeric_local
set_numeric_radix
set_numeric_standard
share_hek
si_dup
ss_dup
pile_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
souillure_propre
dissocier
annuler le partage
utf16_to_utf8
utf16_to_utf8_reversed
uvuni_to_utf8
vdeb
vform
vload_module
vnouveauSVpvf
Vwarner
warn_nocontext
Warner
warner_nocontext
quel signe
quelsig_pv
quelsig_pvn
quelsig_sv

AUTEURS

Jusqu'en mai 1997, ce document était conservé par Jeff Okamoto[email protected]>. Il est
maintenant maintenu dans le cadre de Perl lui-même.

Avec beaucoup d'aide et de suggestions de Dean Roehrich, Malcolm Beattie, Andreas Koenig,
Paul Hudson, Ilya Zakharevitch, Paul Marquess, Neil Bowers, Matthew Green, Tim Bunce,
Spider Boardman, Ulrich Pfeifer, Stephen McCamant et Gurusamy Sarathy.

Liste des API à l'origine par Dean Roehrich[email protected]>.

Mis à jour pour être généré automatiquement à partir des commentaires dans la source par Benjamin Stuhl.

Utilisez perlapi en ligne en utilisant les services onworks.net