perlapi - 云端在线

程序：

您的姓名

perlapi - perl 公共 API 的自动生成文档

商品描述

此文件包含由生成的 perl 公共 API 的文档 嵌入文件,
特别是可能被使用的函数、宏、标志和变量的列表
扩展作家。 最后是尚未记录的功能列表。
这些接口如有更改，恕不另行通知。 此处未列出的任何内容是
不是公共 API 的一部分，并且根本不应由扩展编写者使用。 对于这些
原因，写的时候要避免盲目使用proto.h中列出的函数
扩展。

请注意，必须使用“PL_”前缀来引用所有 Perl API 全局变量。 再次，
此处未列出的内容不应由扩展编写者使用，并且可以更改或
未经通知删除； 与宏相同。 提供了一些宏以兼容
旧的、朴素的名称，但在未来的版本中可能会禁用此支持。

Perl 最初被编写为仅处理 US-ASCII（即其序数为
数字在 0 - 127 范围内）。 并且文档和评论可能仍会使用该术语
ASCII，有时实际上是指 0 - 255 的整个范围。

请注意，Perl 可以在 ASCII 或 EBCDIC 下编译和运行（请参阅 perlebcdic）。
大多数文档（甚至代码中的注释）都忽略了 EBCDIC 的可能性。
对于几乎所有目的，差异都是透明的。 例如，在 EBCDIC 下，
UTF-EBCDIC 用于编码 Unicode 字符串，而不是 UTF-8，因此每当此
文档是指“utf8”（以及该名称的变体，包括在函数名称中），
它也（基本上透明地）表示“UTF-EBCDIC”。 但是字符的序数
ASCII、EBCDIC 和 UTF-编码以及以 UTF-EBCDIC 编码的字符串不同
可能比 UTF-8 占用更多的字节。

下面的列表按字母顺序排列，不区分大小写。

“给我” 理念

GIMME 向后兼容的“GIMME_V”版本，它只能返回“G_SCALAR”或
"G_ARRAY"; 在空上下文中，它返回“G_SCALAR”。 已弃用。 使用“GIMME_V”
代替。

U32 给我

GIMME_V XSUB 编写器相当于 Perl 的“wantarray”。 返回“G_VOID”、“G_SCALAR”
或“G_ARRAY”分别表示空、标量或列表上下文。 见 perlcall
用法示例。

U32 给我_V

G_ARRAY 用于指示列表上下文。 请参阅“GIMME_V”、“GIMME”和 perlcall。

G_丢弃
指示应丢弃从回调返回的参数。 看
调用。

G_EVAL 用于在回调周围强制使用 Perl 的“eval”包装器。 见 perlcall。

G_NOARGS
表示没有参数被发送到回调。 见 perlcall。

G_标量
用于指示标量上下文。 请参阅“GIMME_V”、“GIMME”和 perlcall。

G_VOID 用于指示空上下文。 请参阅“GIMME_V”和 perlcall。

排列 操作 功能

AvFILL 与“av_top_index()”相同。 已弃用，请改用“av_top_index()”。

int AvFILL(AV* av)

AV_清除
释放数组的所有元素，使其为空。 XS 相当于
“@array = ()”。 另见“av_undef”。

请注意，析构函数的操作可能会直接调用或
通过释放数组的元素间接可能导致引用计数
要减少的数组本身（例如，通过删除符号表中的条目）。 所以
AV 可能已被释放（甚至重新分配）
除非您持有对它的引用，否则从调用中返回。

无效 av_clear(AV *av)

av_create_and_push
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将一个 SV 推到数组的末尾，必要时创建数组。 一个小的
内部辅助函数，用于删除常见重复的习语。

无效 av_create_and_push(AV **const avp,
SV *常量值)

av_create_and_unshift_one
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将 SV 移到数组的开头，必要时创建数组。
一个小的内部帮助函数，用于删除常见的重复习语。

SV** av_create_and_unshift_one(AV **const avp,
SV *常量值)

av_删除
从数组中删除由“key”索引的元素，使该元素死亡，并且
返回它。 如果“flags”等于“G_DISCARD”，则释放该元素并且 null 为
回。 Perl 等效：“我的 $elem = delete($myarray[$idx]);” 为了
非“G_DISCARD”版本和空上下文“delete($myarray[$idx]);” 为了
“G_DISCARD”版本。

SV* av_delete(AV *av, SSize_t 键, I32 标志)

av_存在
如果由“key”索引的元素已初始化，则返回 true。

这依赖于未初始化的数组元素设置为 NULL 的事实。

Perl 等效项：“存在（$myarray[$key]）”。

bool av_exists(AV *av, SSize_t 键)

AV_扩展
预先扩展一个数组。 “键”是数组应该指向的索引
扩展。

void av_extend(AV *av, SSize_t 键)

av_fetch
返回数组中指定索引处的 SV。 “键”是索引。 如果
lval 是真的，你肯定会得到一个真正的 SV（以防它不是真的
之前），然后您可以对其进行修改。 检查返回值是否为非空
在将其取消引用为“SV*”之前。

有关更多信息，请参阅 perlguts 中的“了解绑定哈希和数组的魔力”
有关如何在绑定数组上使用此函数的信息。

粗略的 perl 等价物是 $myarray[$idx]。

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

av_fill 将数组中的最高索引设置为给定的数字，相当于 Perl 的
“$#array = $fill;”。

数组中的元素数将在“填充+1”之后 av_fill() 回报。
如果数组以前较短，则设置附加的附加元素
为 NULL。 如果数组更长，则释放多余的元素。
“av_fill(av, -1)”与“av_clear(av)”相同。

void av_fill(AV *av, SSize_t 填充)

av_len 与“av_top_index”相同。 请注意，与名称所暗示的不同，它返回
数组中的最高索引，因此要获得您需要使用的数组大小
“av_len(av) + 1”。 这与“sv_len”不同，它返回您期望的内容。

SSize_t av_len(AV *av)

av_make 创建一个新的 AV 并用 SV 列表填充它。 SV 被复制到
数组，因此它们可能在调用 av_make 后被释放。 新的 AV 将有一个
引用计数为 1。

Perl 等效：“我的@new_array = ($scalar1, $scalar2, $scalar3...);”

AV* av_make(SSize_t 大小，SV **strp)

av_pop 从数组末尾移除一个 SV，将其大小减一并返回
SV（将一个引用计数的控制权转移给调用者）。 退货
&PL_sv_undef 如果数组为空。

Perl 等效："pop(@myarray);"

SV* av_pop(AV *av)

av_push 将 SV 推送到数组的末尾。 数组将自动增长到
容纳添加。 这需要一个引用计数的所有权。

Perl 等效项：“push @myarray, $elem;”​​。

无效 av_push(AV *av, SV *val)

AV_Shift
从数组的开头删除一个 SV，将其大小减一并返回
SV（将一个引用计数的控制权转移给调用者）。 退货
&PL_sv_undef 如果数组为空。

Perl 等效项：“shift(@myarray);”

SV* av_shift(AV *av)

AV_商店
将 SV 存储在数组中。 数组索引被指定为“key”。 回报
如果操作失败或不需要值，则值为 NULL
实际上存储在数组中（如绑定数组的情况）。 否则，它
可以取消引用以获取存储在那里的“SV*”（=“val”））。

请注意，调用者负责适当地增加引用计数
调用之前的“val”，如果函数返回 NULL，则递减它。

近似 Perl 等效项：“$myarray[$key] = $val;”。

有关更多信息，请参阅 perlguts 中的“了解绑定哈希和数组的魔力”
有关如何在绑定数组上使用此函数的信息。

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

AV_T索引
与“av_top_index()”相同。

int av_tindex(AV* av)

av_top_index
返回数组中的最高索引。 数组中的元素个数为
“av_top_index(av) + 1”。 如果数组为空，则返回 -1。

与此等效的 Perl 是 $#myarray。

（略短的形式是“av_tindex”。）

SSize_t av_top_index(AV *av)

av_undef
取消定义数组。 XS 等效于“undef(@array)”。

除了释放数组的所有元素（如“av_clear()”），这也
释放 av 用于存储其标量列表的内存。

有关数组可能在返回时无效的注释，请参阅“av_clear”。

无效 av_undef(AV *av)

av_unshift
将给定数量的“undef”值取消移动到数组的开头。 这
数组将自动增长以适应添加。 然后你必须使用
“av_store”为这些新元素赋值。

Perl 等效项：“unshift @myarray, ( (undef) x $n );”

void av_unshift(AV *av, SSize_t num)

get_av 返回具有给定名称的指定 Perl 全局或包数组的 AV
（因此它不适用于词法变量）。 “标志”被传递给“gv_fetchpv”。 如果
"GV_ADD" 被设置并且 Perl 变量不存在然后它会被创建。 如果
“flags”为零且变量不存在，则返回 NULL。

Perl 等效项："@{"$name"}"。

注意：不推荐使用此函数的 perl_ 形式。

AV* get_av(const char *name, I32 标志)

newAV 创建一个新的 AV。 引用计数设置为 1。

Perl 等效：“我的@array;”。

AV* 新AV()

sortsv 对数组进行排序。 下面是一个例子：

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

目前这总是使用归并排序。 有关更灵活的信息，请参阅 sortsv_flags
常规。

void sortsv(SV** 数组，size_t num_elts，
SVCOMPARE_t cmp)

sortsv_flags
使用各种选项对数组进行排序。

void sortsv_flags(SV** 数组，size_t num_elts，
SVCOMPARE_t cmp，U32 标志）

“xsubpp” 变量 和 内部 功能

ax 变量，由“xsubpp”设置以指示堆栈基址偏移量，由
“ST”、“XSprePUSH”和“XSRETURN”宏。 必须先调用“dMARK”宏
设置“MARK”变量。

I32斧

CLASS 变量，由“xsubpp”设置以指示 C++ XS 的类名
构造函数。 这始终是“字符*”。 见“这个”。

字符* 类

dAX 设置“ax”变量。 这通常由“xsubpp”自动处理
调用“dXSARGS”。

达克斯;

dAXMARK 设置“ax”变量和堆栈标记变量“mark”。 这通常是
“xsubpp”通过调用“dXSARGS”自动处理。

达马克；

dITEMS 设置“items”变量。 这通常由“xsubpp”自动处理
通过调用“dXSARGS”。

项目；

邓德巴
设置“UNDERBAR”宏所需的任何变量。 它曾经定义
“padoff_du”，但它目前是一个 noop。 但是，强烈建议仍然
使用它来确保过去和未来的兼容性。

邓德巴;

dXSARGS 为 XSUB 设置堆栈和标记指针，调用 dSP 和 dMARK。 设置
“ax”和“items”变量通过调用“dAX”和“dITEMS”。 通常是这样处理的
由“xsubpp”自动执行。

dXSARGS；

dXSI32 为具有别名的 XSUB 设置“ix”变量。 通常是这样处理的
由“xsubpp”自动执行。

DXSI32；

items 变量，由“xsubpp”设置以指示堆栈上的项目数。
请参阅 perlxs 中的“可变长度参数列表”。

I32 项目

ix 由“xsubpp”设置的变量，用于指示 XSUB 的哪个别名是
用来调用它。 请参阅 perlxs 中的“别名：关键字”。

I32 九

RETVAL 变量，由“xsubpp”设置以保存 XSUB 的返回值。 这是
始终是 XSUB 的正确类型。 请参阅 perlxs 中的“RETVAL 变量”。

(无论如何) RETVAL

ST 用于访问 XSUB 堆栈上的元素。

SV* ST(整数 ix)

此变量由“xsubpp”设置以指定 C++ XSUB 中的对象。 这
始终是 C++ 对象的正确类型。 请参阅“类”和“在 C++ 中使用 XS”
在perlxs。

（随便）这个

下杠
对应于 $_ 变量的 SV*。 即使有词法 $_ 也能工作
范围。

XS 宏来声明 XSUB 及其 C 参数列表。 这由“xsubpp”处理。
它与使用更明确的 XS_EXTERNAL 宏相同。

XS_外部
用于声明 XSUB 及其 C 参数列表的宏，显式导出
符号。

XS_内部
用于声明 XSUB 及其 C 参数列表而不导出符号的宏。
这由“xsubpp”处理，通常优于导出 XSUB
不必要的符号。

打回来 功能

调用参数
执行对指定的命名和包范围的 Perl 子例程的回调
“argv”（以 NULL 结尾的字符串数组）作为参数。 见 perlcall。

近似的 Perl 等效项："&{"$sub_name"}(@$argv)"。

注意：不推荐使用此函数的 perl_ 形式。

I32 call_argv(const char* sub_name, I32 标志,
字符** argv)

调用方法
执行对指定 Perl 方法的回调。 被祝福的对象必须在
堆栈。 见 perlcall。

注意：不推荐使用此函数的 perl_ 形式。

I32 call_method（const char* 方法名，I32 标志）

call_pv 对指定的 Perl 子执行回调。 见 perlcall。

注意：不推荐使用此函数的 perl_ 形式。

I32 call_pv(const char* sub_name, I32 标志)

call_sv 执行对 SV 指定的 Perl sub 的回调。

如果“G_METHOD”或“G_METHOD_NAMED”标志均未提供，则 SV 可以是任何
将使用 CV、GV、对 CV 的引用、对 GV 的引用或“SvPV(sv)”
作为要调用的子的名称。

如果提供了“G_METHOD”标志，则 SV 可能是对 CV 或
“SvPV(sv)”将用作要调用的方法的名称。

如果提供了“G_METHOD_NAMED”标志，则“SvPV(sv)”将用作
要调用的方法。

其他一些值是专门为内部使用而处理的，不应
取决于。

见 perlcall。

注意：不推荐使用此函数的 perl_ 形式。

I32 call_sv(SV* sv, VOL I32 标志)

ENTER 回调的左括号。 请参阅“离开”和 perlcall。

进入;

eval_pv 告诉 Perl 在标量上下文中“评估”给定的字符串并返回一个 SV* 结果。

注意：不推荐使用此函数的 perl_ 形式。

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

eval_sv 告诉 Perl 对 SV 中的字符串进行“评估”。 它支持与相同的标志
“call_sv”，G_EVAL 显然是个例外。 见 perlcall。

注意：不推荐使用此函数的 perl_ 形式。

I32 eval_sv(SV* sv, I32 标志)

免税店
回调临时对象的右括号。 请参阅“SAVETMPS”和 perlcall。

自由时间；

LEAVE 结束回调。 请参阅“输入”和 perlcall。

离开;

保存时间
回调临时变量的左括号。 请参阅“FREETMPS”和 perlcall。

保存时间；

字符 案件 改变

toFOLD 将指定字符转换为折叠大小写。 如果输入不是一个
ASCII 大写字符，返回输入字符本身。 变体
“toFOLD_A”是等价的。 （完整的没有等效的“to_FOLD_L1”
Latin1 范围，因为那里需要“toFOLD_uni”的完整通用性。）

U8 到折叠（U8 通道）

toFOLD_uni
将 Unicode 代码点“cp”转换为其折叠版本，并将其存储在
“s”中的 UTF-8，“lenp”中的字节长度。 请注意，缓冲区指向
由 "s" 需要至少 "UTF8_MAXBYTES_CASE+1" 字节，因为折叠箱
版本可能比原始字符长。

返回折叠版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

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

toFOLD_utf8
将 "p" 处的 UTF-8 编码字符转换为其折叠版本，并存储
UTF-8 中的“s”，以及“lenp”中的字节长度。 注意缓冲区
“s”指向的至少需要“UTF8_MAXBYTES_CASE+1”字节，因为
foldcase 版本可能比原始字符长。

返回折叠版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

“p”处的输入字符被假定为格式良好的。

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

toLOWER 将指定字符转换为小写。 如果输入不是一个
ASCII 大写字符，返回输入字符本身。 变体
“toLOWER_A”是等价的。

U8 to LOWER(U8 ch)

到LOWER_L1
将指定的 Latin1 字符转换为小写。 结果未定
如果输入不适合一个字节。

U8 到LOWER_L1(U8 通道)

到LOWER_LC
使用当前语言环境的规则将指定字符转换为小写，如果
可能的; 否则返回输入字符本身。

U8 到LOWER_LC(U8 通道)

到LOWER_uni
将 Unicode 代码点“cp”转换为其小写版本，并将其存储在
“s”中的 UTF-8，“lenp”中的字节长度。 请注意，缓冲区指向
by "s" 需要至少 "UTF8_MAXBYTES_CASE+1" 字节，因为小写
版本可能比原始字符长。

返回小写版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

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

toLOWER_utf8
将 "p" 处的 UTF-8 编码字符转换为其小写版本，并存储
UTF-8 中的“s”，以及“lenp”中的字节长度。 注意缓冲区
“s”指向的至少需要“UTF8_MAXBYTES_CASE+1”字节，因为
小写版本可能比原始字符长。

返回小写版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

“p”处的输入字符被假定为格式良好的。

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

toTITLE 将指定的字符转换为标题。 如果输入不是一个
ASCII 小写字符，返回输入字符本身。 变体
“toTITLE_A”是等价的。 （完整的 Latin1 范围没有“toTITLE_L1”，
因为那里需要“toTITLE_uni”的完整通用性。 Titlecase 不是
语言环境处理中使用的概念，因此没有相应的功能。）

U8 toTITLE(U8 通道)

到TITLE_uni
将 Unicode 代码点“cp”转换为其标题版本，并将其存储在
“s”中的 UTF-8，“lenp”中的字节长度。 请注意，缓冲区指向
从标题开始，“s”至少需要“UTF8_MAXBYTES_CASE+1”字节
版本可能比原始字符长。

返回标题版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

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

toTITLE_utf8
将“p”处的 UTF-8 编码字符转换为其标题版本，并存储
UTF-8 中的“s”，以及“lenp”中的字节长度。 注意缓冲区
“s”指向的至少需要“UTF8_MAXBYTES_CASE+1”字节，因为
titlecase 版本可能比原始字符长。

返回标题版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

“p”处的输入字符被假定为格式良好的。

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

toUPPER 将指定字符转换为大写。 如果输入不是一个
ASCII 小写字符，返回输入字符本身。 变体
“toUPPER_A”是等价的。

U8到UPPER(U8通道)

到UPPER_uni
将 Unicode 代码点“cp”转换为其大写版本，并将其存储在
“s”中的 UTF-8，“lenp”中的字节长度。 请注意，缓冲区指向
by "s" 需要至少 "UTF8_MAXBYTES_CASE+1" 字节，因为大写
版本可能比原始字符长。

返回大写版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

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

toUPPER_utf8
将 "p" 处的 UTF-8 编码字符转换为其大写版本，并存储
UTF-8 中的“s”，以及“lenp”中的字节长度。 注意缓冲区
“s”指向的至少需要“UTF8_MAXBYTES_CASE+1”字节，因为
大写版本可能比原始字符长。

返回大写版本的第一个代码点（但请注意，如解释
就在上面，可能还有更多。）

“p”处的输入字符被假定为格式良好的。

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

字符 分类

本节是关于将字符分类为类型的函数（实际上是宏），例如
如标点符号与字母等。其中大部分类似于正则表达式
字符类。 （请参阅 perlrecharclass 中的“POSIX 字符类”。）有几个
每个类的变体。 （并非所有宏都有所有变体；下面的每一项都列出了
对它有效。）不受“使用字节”的影响，只有在“使用字节”中的那些
name 受当前语言环境的影响。

基本函数，例如“isALPHA()”，将一个八位字节（“char”或“U8”）作为输入
并返回一个布尔值，关于该八位字节表示的字符是否是（或
在非 ASCII 平台上，对应于）命名类中的 ASCII 字符基于
平台、Unicode 和 Perl 规则。 如果输入是一个不适合八位字节的数字，
返回 FALSE。

变体“isFOO_A”（例如，“isALPHA_A()”）与没有后缀的基本函数相同
“_一个”。

变体“isFOO_L1”将 Latin-1（或 EBCDIC 等效）字符集强加到
平台。 也就是说，作为 ASCII 的代码点不受影响，因为 ASCII 是一个子集
拉丁语 1。 但非 ASCII 代码点被视为拉丁 1 字符。
例如，当使用代码点 1xDF 调用时，“isWORDCHAR_L0()”将返回 true，
它是 ASCII 和 EBCDIC 中的单词字符（尽管它代表不同的
每个字符）。

变体“isFOO_uni”类似于“isFOO_L1”变体，但接受任何 UV 代码点作为
输入。 如果码位大于 255，则使用 Unicode 规则来判断是否为
在字符类中。 例如， ”是WORDCHAR_uni(0x100)" 返回 TRUE，因为 0x100 是
Unicode 中带有 MACRON 的拉丁文大写字母 A，是一个单词字符。

变体“isFOO_utf8”类似于“isFOO_uni”，但输入是指向 a（已知为
格式良好）UTF-8 编码的字符串（“U8*”或“char*”）。 只是分类
测试字符串中的第一个（可能是多字节）字符。

变体“isFOO_LC”类似于“isFOO_A”和“isFOO_L1”变体，但结果是基于
在当前语言环境中，这就是名称中的“LC”所代表的含义。 如果 Perl 可以确定
当前语言环境是 UTF-8 语言环境，它使用已发布的 Unicode 规则； 否则，
它使用提供命名分类的 C 库函数。 例如，
“isDIGIT_LC()”当不在 UTF-8 语言环境中时返回调用“isdigit()”的结果。
如果输入不适合八位字节，则始终返回 FALSE。 在某些平台上
已知 C 库函数有缺陷，Perl 更改其结果以遵循
POSIX 标准的规则。

变体“isFOO_LC_uvchr”类似于“isFOO_LC”，但定义在任何UV上。 它返回
对于小于 256 的输入代码点，与“isFOO_LC”相同，并返回硬编码的，非-
受语言环境影响，较大的 Unicode 结果。

变体“isFOO_LC_utf8”类似于“isFOO_LC_uvchr”，但输入是指向a（已知
格式正确）UTF-8 编码的字符串（“U8*”或“char*”）。 刚刚的分类
测试字符串中的第一个（可能是多字节）字符。

isALPHA 返回一个布尔值，指示指定的字符是否为字母
字符，类似于“m/[[:alpha:]]]/”。 请参阅本节顶部的
变体“isALPHA_A”、“isALPHA_L1”、“isALPHA_uni”、“isALPHA_utf8”的解释，
“isALPHA_LC”、“isALPHA_LC_uvchr”和“isALPHA_LC_utf8”。

bool isALPHA(字符 ch)

是字母数字
返回一个布尔值，指示指定的字符是否为
字母字符或十进制数字，类似于“m/[[:alnum:]]/”。 见顶部
本节的解释变体“isALPHANUMERIC_A”，
"isALPHANUMERIC_L1", "isALPHANUMERIC_uni", "isALPHANUMERIC_utf8",
“isALPHANUMERIC_LC”、“isALPHANUMERIC_LC_uvchr”和“isALPHANUMERIC_LC_utf8”。

bool isALPHANUMERIC(char ch)

isASCII 返回一个布尔值，指示指定的字符是否是 128 个字符之一
ASCII 字符集中的字符，类似于“m/[[:ascii:]]]/”。 在非
ASCII 平台，如果此字符对应于 ASCII，则返回 TRUE
特点。 变体“isASCII_A()”和“isASCII_L1()”与
“isASCII()”。 有关变体的说明，请参阅本节顶部
“isASCII_uni”、“isASCII_utf8”、“isASCII_LC”、“isASCII_LC_uvchr”和
“isASCII_LC_utf8”。 但是请注意，某些平台没有 C 库
例行程序“isascii()”。 在这些情况下，名称包含“LC”的变体是
和没有的对应的一样。

另请注意，因为所有 ASCII 字符都是 UTF-8 不变的（意味着它们
无论是否以 UTF-8 编码，都具有完全相同的表示（始终为单个字节）
与否），“isASCII”将在使用任何字节调用时给出正确的结果
字符串是否以 UTF-8 编码。 同样“isASCII_utf8”也能正常工作
在任何以 UTF-8 编码或不编码的字符串上。

bool isASCII(字符 ch)

isBLANK 返回一个布尔值，指示指定的字符是否为字符
被认为是空白，类似于“m/[[:blank:]]/”。 看到这个顶部
变体“isBLANK_A”、“isBLANK_L1”、“isBLANK_uni”的解释部分，
“isBLANK_utf8”、“isBLANK_LC”、“isBLANK_LC_uvchr”和“isBLANK_LC_utf8”。 笔记，
但是，某些平台没有 C 库例程“isblank()”。 在
在这些情况下，名称包含“LC”的变体与
相应的没有。

bool isBLANK(字符 ch)

isCNTRL 返回一个布尔值，指示指定的字符是否为控件
字符，类似于“m/[[:cntrl:]]/”。 请参阅本节顶部的
变体“isCNTRL_A”、“isCNTRL_L1”、“isCNTRL_uni”、“isCNTRL_utf8”的解释，
“isCNTRL_LC”、“isCNTRL_LC_uvchr”和“isCNTRL_LC_utf8” 在 EBCDIC 平台上，您
几乎总是想使用“isCNTRL_L1”变体。

bool isCNTRL(char ch)

isDIGIT 返回一个布尔值，指示指定的字符是否为数字，类似
到“m/[[:digit:]]/”。 变体“isDIGIT_A”和“isDIGIT_L1”与
“是数字”。 有关变体的说明，请参阅本节顶部
“isDIGIT_uni”、“isDIGIT_utf8”、“isDIGIT_LC”、“isDIGIT_LC_uvchr”和
“isDIGIT_LC_utf8”。

bool isDIGIT(字符 ch)

isGRAPH 返回一个布尔值，指示指定的字符是否为图形
字符，类似于“m/[[:graph:]]]/”。 请参阅本节顶部的
变体“isGRAPH_A”、“isGRAPH_L1”、“isGRAPH_uni”、“isGRAPH_utf8”的解释，
“isGRAPH_LC”、“isGRAPH_LC_uvchr”和“isGRAPH_LC_utf8”。

bool isGRAPH(字符 ch)

是IDCCON
返回一个布尔值，指示指定的字符是否可以是第二个或
标识符的后继字符。 这非常接近，但不完全是
与官方 Unicode 属性“XID_Continue”相同。 不同的是，这
仅当输入字符也匹配“isWORDCHAR”时才返回真。 见顶部
本节的解释变体“isIDCONT_A”，“isIDCONT_L1”，
“isIDCONT_uni”、“isIDCONT_utf8”、“isIDCONT_LC”、“isIDCONT_LC_uvchr”和
“isIDCONT_LC_utf8”。

bool isIDCONT(char ch)

是IDFIRST
返回一个布尔值，指示指定的字符是否可以是第一个
标识符的字符。 这非常接近，但并不完全相同
官方 Unicode 属性“XID_Start”。 不同之处在于这返回true
仅当输入字符也匹配“isWORDCHAR”时。 看到这个顶部
用于解释变体“isIDFIRST_A”、“isIDFIRST_L1”的部分，
“isIDFIRST_uni”、“isIDFIRST_utf8”、“isIDFIRST_LC”、“isIDFIRST_LC_uvchr”和
“isIDFIRST_LC_utf8”。

布尔 isIDFIRST（字符 ch）

isLOWER 返回一个布尔值，指示指定的字符是否为小写
字符，类似于“m/[[[:lower:]]]/”。 请参阅本节顶部的
变体“isLOWER_A”、“isLOWER_L1”、“isLOWER_uni”、“isLOWER_utf8”的解释，
“isLOWER_LC”、“isLOWER_LC_uvchr”和“isLOWER_LC_utf8”。

bool isLOWER(char ch)

isOCTAL 返回一个布尔值，指示指定的字符是否是八进制数字，
[0-7]。 仅有的两个变体是“isOCTAL_A”和“isOCTAL_L1”； 每个都是相同的
到“isOCTAL”。

bool isOCTAL(字符 ch)

isPRINT 返回一个布尔值，指示指定的字符是否是可打印的
字符，类似于“m/[[[:print:]]]/”。 请参阅本节顶部的
变体“isPRINT_A”、“isPRINT_L1”、“isPRINT_uni”、“isPRINT_utf8”的解释，
“isPRINT_LC”、“isPRINT_LC_uvchr”和“isPRINT_LC_utf8”。

bool isPRINT(字符 ch)

是PSXSPC
（Posix Space 的缩写）从 5.18 开始，它的所有形式都与
相应的“isSPACE()”宏。 这个宏的语言环境形式是
与所有 Perl 版本中对应的“isSPACE()”形式相同。 在
5.18 之前的版本，非语言环境形式不同于它们的“isSPACE()”形式
只是因为“isSPACE()”形式与垂直制表符不匹配，并且
“isPSXSPC()”形式可以。 否则它们是相同的。 因此这个宏是
类似于正则表达式中的“m/[[:space:]]/”匹配。 见顶部
本节的解释变体“isPSXSPC_A”，“isPSXSPC_L1”，
“isPSXSPC_uni”、“isPSXSPC_utf8”、“isPSXSPC_LC”、“isPSXSPC_LC_uvchr”和
“isPSXSPC_LC_utf8”。

布尔 isPSXSPC（字符 ch）

isPUNCT 返回一个布尔值，指示指定的字符是否为标点符号
字符，类似于“m/[[:punct:]]]/”。 注意 what 的定义
标点符号并不像人们希望的那样简单。 请参阅“POSIX 字符
详情请参阅 perlrecharclass 中的 Classes”。有关详细信息，请参阅本节的顶部
变体“isPUNCT_A”、“isPUNCT_L1”、“isPUNCT_uni”、“isPUNCT_utf8”的解释，
“isPUNCT_LC”、“isPUNCT_LC_uvchr”和“isPUNCT_LC_utf8”。

布尔 isPUNCT(字符 ch)

isSPACE 返回一个布尔值，指示指定的字符是否为空格
特点。 这类似于正则表达式中的“m/\s/”匹配项。
从 Perl 5.18 开始，这也匹配 "m/[[:space:]]/" 所做的。 之前
5.18, 仅此宏的语言环境形式（名称中带有“LC”的那些）
完全匹配 "m/[[:space:]]/" 的作用。 在这些版本中，唯一的
在非语言环境变体中，不同之处在于“isSPACE()”与
垂直标签。 （有关匹配所有垂直制表符的宏，请参阅“isPSXSPC”
版本。）有关变体的说明，请参阅本节的顶部
"isSPACE_A", "isSPACE_L1", "isSPACE_uni", "isSPACE_utf8", "isSPACE_LC",
“isSPACE_LC_uvchr”和“isSPACE_LC_utf8”。

bool isSPACE(char ch)

isUPPER 返回一个布尔值，指示指定的字符是否为大写
字符，类似于“m/[[[:upper:]]]/”。 请参阅本节顶部的
变体“isUPPER_A”、“isUPPER_L1”、“isUPPER_uni”、“isUPPER_utf8”的解释，
“isUPPER_LC”、“isUPPER_LC_uvchr”和“isUPPER_LC_utf8”。

bool isUPPER(char ch)

是WORDCHAR
返回一个布尔值，指示指定的字符是否为
是一个单词字符，类似于 "m/\w/" 和 "m/[[[:word:]]/" 匹配
正则表达式。 一个单词字符是一个字母字符，一个十进制数字，
连接标点符号（例如下划线）或“标记”字符
附加到其中一个（如某种口音）。 “isALNUM()”是一个
为向后兼容而提供的同义词，即使单词字符包括
超过标准C语言字母数字的含义。 看到这个顶部
变体“isWORDCHAR_A”、“isWORDCHAR_L1”的解释部分，
“isWORDCHAR_uni”和“isWORDCHAR_utf8”。 "isWORDCHAR_LC", "isWORDCHAR_LC_uvchr",
和“isWORDCHAR_LC_utf8”也如那里所述，但另外包括
平台的原生下划线。

bool isWORDCHAR(char ch)

是XDIGIT
返回一个布尔值，指示指定的字符是否为十六进制
数字。 在 ASCII 范围内，这些是“[0-9A-Fa-f]”。 变体“isXDIGIT_A()”和
“isXDIGIT_L1()”与“isXDIGIT()”相同。 请参阅本节顶部的
变体“isXDIGIT_uni”、“isXDIGIT_utf8”、“isXDIGIT_LC”的解释，
“isXDIGIT_LC_uvchr”和“isXDIGIT_LC_utf8”。

bool isXDIGIT(字符 ch)

克隆 an 翻译员

perl_clone
通过克隆当前的解释器来创建并返回一个新的解释器。

perl_clone 将这些标志作为参数：

CLONEf_COPY_STACKS - 也用于复制堆栈，没有它我们只能
克隆数据并将堆栈归零，我们用它复制堆栈和新的 perl
解释器已准备好在与前一个完全相同的点运行。 这
伪分叉代码使用 COPY_STACKS 而线程->create 不使用。

CLONEf_KEEP_PTR_TABLE - perl_clone 保留一个带有旧指针的 ptr_table
变量作为键，新变量作为值，这允许它检查是否
某些东西已被克隆，不再克隆它，而只是使用该值和
增加引用计数。 如果 KEEP_PTR_TABLE 未设置，则 perl_clone 将杀死
ptr_table 使用函数“ptr_table_free(PL_ptr_table); PL_ptr_table = NULL;”，
保留它的原因是如果你想复制一些你自己的变量
在图 perl 扫描之外，此代码的示例在threads.xs 创建中。

CLONEf_CLONE_HOST - 这是一个 win32 的东西，在 unix 上被忽略，它告诉 perls
win32host 代码（它是 C++）来克隆自己，如果你想的话，这在 win32 上是需要的
同时运行两个线程，如果你只是想在一个
分离 perl 解释器，然后将其丢弃并返回原始解释器，
你不需要做任何事情。

Perl解释器* perl_clone(
Perl解释器*proto_perl，
紫外线标志
)

编译时间 范围 挂钩

禁用
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

暂时禁用此 BHK 结构中的条目，方法是清除相应的
旗。 这 是一个预处理器令牌，指示要禁用哪个条目。

void BhkDISABLE(BHK *hk, 其中)

启用
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

通过设置适当的标志，重新启用此 BHK 结构中的条目。 这
是一个预处理器令牌，指示要启用哪个条目。 这将断言（在
-DDEBUGGING) 如果条目不包含有效的指针。

void BhkENABLE(BHK *hk, 其中)

BhkENTRY_set
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在 BHK 结构中设置一个条目，并设置标志以表明它是有效的。
这 是一个预处理标记，指示要设置哪个条目。 的类型 PTR
取决于入口。

void BhkENTRY_set(BHK *hk, 其中, void *ptr)

块钩子寄存器
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

注册一组钩子，当 Perl 词法范围改变时调用
编译时间。 请参阅 perlguts 中的“编译时范围挂钩”。

注意：此函数必须显式调用为 Perl_blockhook_register，并带有
aTHX_ 参数。

void Perl_blockhook_register(pTHX_ BHK *hk)

缔约方会议 提示 哈希

COPH_2HV
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

生成并返回表示完整键/值集的标准 Perl 哈希
警察提示哈希中的对 头骨. 标志 当前未使用且必须为零。

HV * cophh_2hv（const COPHH *cophh，U32 标志）

COPH_副本
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

制作并返回完整的警察提示哈希副本 头骨.

COPHH * cophh_copy(COPHH *cophh)

COPH_删除_PV
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_delete_pvn”，但采用以空字符结尾的字符串而不是
字符串/长度对。

COPHH * cophh_delete_pv(const COPHH *cophh,
const char *key，U32 哈希，
U32 标志）

COPH_删除_pvn
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

从 cop 提示哈希中删除一个键及其关联的值 头骨，并返回
修改后的哈希。 返回的哈希指针通常与
传入的散列指针。输入散列被函数消耗，并且
随后不得使用指向它的指针。 如果需要，请使用“cophh_copy”
两个哈希。

密钥由 密钥 和 钥匙圈。 如果 标志 有“COPHH_KEY_UTF8”位
设置，关键八位字节被解释为 UTF-8，否则它们被解释为
拉丁语-1。 哈希 是密钥字符串的预先计算的哈希值，如果没有，则为零
预先计算。

COPHH * cophh_delete_pvn(COPHH *cophh,
常量字符 *keypv,
STRLEN 密钥，U32 哈希，
U32 标志）

cophh_delete_pvs
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_delete_pvn”，但采用文字字符串而不是字符串/长度
对，并且没有预先计算的哈希值。

COPHH * cophh_delete_pvs(const COPHH *cophh,
const char *key，U32 标志）

cophh_delete_sv
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于 "cophh_delete_pvn"，但采用 Perl 标量而不是字符串/长度对。

COPHH * cophh_delete_sv(const COPHH *cophh, SV *key,
U32 哈希，U32 标志）

cophh_fetch_pv
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_fetch_pvn”，但采用以空字符结尾的字符串而不是
字符串/长度对。

SV * cophh_fetch_pv(const COPHH *cophh,
const char *key，U32 哈希，
U32 标志）

cophh_fetch_pvn
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在警察提示哈希中查找条目 头骨 使用指定的键 密钥 和
钥匙圈。 如果 标志 设置了“COPHH_KEY_UTF8”位，解释了关键八位字节
作为 UTF-8，否则它们将被解释为 Latin-1。 哈希 是预先计算的哈希
键字符串，如果尚未预先计算，则为零。 返回一个凡人
与键关联的值的标量副本，或者 &PL_sv_placeholder 如果有
没有与键关联的值。

SV * cophh_fetch_pvn(const COPHH *cophh,
常量字符 *keypv,
STRLEN 密钥，U32 哈希，
U32 标志）

cophh_fetch_pvs
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_fetch_pvn”，但采用文字字符串而不是字符串/长度
对，并且没有预先计算的哈希值。

SV * cophh_fetch_pvs(const COPHH *cophh,
const char *key，U32 标志）

cophh_fetch_sv
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_fetch_pvn”，但采用 Perl 标量而不是字符串/长度对。

SV * cophh_fetch_sv(const COPHH *cophh, SV *key,
U32 哈希，U32 标志）

COPH_free
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

丢弃警察提示哈希 头骨，释放与之相关的所有资源。

无效 cophh_free(COPHH *cophh)

COPH_新_空
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

生成并返回一个不包含任何条目的新 cop 提示哈希。

COPHH * cophh_new_empty()

COPH_商店_PV
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_store_pvn”，但采用以空字符结尾的字符串而不是
字符串/长度对。

COPHH * cophh_store_pv(const COPHH *cophh,
const char *key，U32 哈希，
SV *值，U32 标志）

COPH_商店_pvn
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在 cop 提示散列中存储与键关联的值 头骨，并返回
修改后的哈希。 返回的哈希指针通常与
传入的散列指针。输入散列被函数消耗，并且
随后不得使用指向它的指针。 如果需要，请使用“cophh_copy”
两个哈希。

密钥由 密钥 和 钥匙圈。 如果 标志 有“COPHH_KEY_UTF8”位
设置，关键八位字节被解释为 UTF-8，否则它们被解释为
拉丁语-1。 哈希 是密钥字符串的预先计算的哈希值，如果没有，则为零
预先计算。

折扣值 是要为此键存储的标量值。 折扣值 被这个复制了
函数，因此不拥有对它的任何引用的所有权，后来
对标量的更改不会反映在 cop 提示中可见的值中
哈希。 复杂类型的标量不会以参照完整性存储，但
将被强制为字符串。

COPHH * cophh_store_pvn(COPHH *cophh, const char *keypv,
STRLEN 密钥，U32 哈希，
SV *值，U32 标志）

cophh_store_pvs
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_store_pvn”，但采用文字字符串而不是字符串/长度
对，并且没有预先计算的哈希值。

COPHH * cophh_store_pvs(const COPHH *cophh,
const char *键，SV *值，
U32 标志）

COPH_商店_SV
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

类似于“cophh_store_pvn”，但采用 Perl 标量而不是字符串/长度对。

COPHH * cophh_store_sv(const COPHH *cophh, SV *key,
U32 哈希、SV *值、U32 标志）

缔约方会议 提示 阅读

cop_hints_2hv
生成并返回表示完整提示集的标准 Perl 哈希
警察中的条目 警察. 标志 当前未使用且必须为零。

HV * cop_hints_2hv（const COP *cop，U32 标志）

cop_hints_fetch_pv
类似于“cop_hints_fetch_pvn”，但采用以空字符结尾的字符串而不是
字符串/长度对。

SV * cop_hints_fetch_pv(const COP *cop,
const char *key，U32 哈希，
U32 标志）

cop_hints_fetch_pvn
在警察中查找提示条目 警察 使用指定的键 密钥 和 钥匙圈.
If 标志 设置了“COPHH_KEY_UTF8”位，关键八位字节被解释为
UTF-8，否则它们将被解释为 Latin-1。 哈希 是预先计算的散列
密钥字符串，如果尚未预先计算，则为零。 返回一个凡人标量
与键关联的值的副本，如果没有，则为 &PL_sv_placeholder
与键关联的值。

SV * cop_hints_fetch_pvn(const COP *cop,
常量字符 *keypv,
STRLEN 密钥，U32 哈希，
U32 标志）

cop_hints_fetch_pvs
类似于“cop_hints_fetch_pvn”，但采用文字字符串而不是字符串/长度
对，并且没有预先计算的哈希值。

SV * cop_hints_fetch_pvs(const COP *cop,
const char *key，U32 标志）

cop_hints_fetch_sv
类似于“cop_hints_fetch_pvn”，但采用 Perl 标量而不是字符串/长度
对。

SV * cop_hints_fetch_sv(const COP *cop, SV *key,
U32 哈希，U32 标志）

定制 运营商

自定义操作注册
注册自定义操作。 请参阅 perlguts 中的“自定义运算符”。

注意：这个函数必须被显式调用为 Perl_custom_op_register
aTHX_ 参数。

无效 Perl_custom_op_register(pTHX_
Perl_ppaddr_t ppaddr，
常量 XOP *xop)

自定义操作xop
返回给定自定义操作的 XOP 结构。 应该考虑这个宏
OP_NAME 和其他访问宏的内部：改用它们。 这个宏
确实调用了一个函数。 在 5.19.6 之前，这是作为函数实现的。

注意：此函数必须显式调用为 Perl_custom_op_xop 并带有 aTHX_
参数。

const XOP * Perl_custom_op_xop(pTHX_ const OP *o)

禁用
通过清除相应的标志，暂时禁用 XOP 的成员。

无效 XopDISABLE（XOP *xop，其中）

Xop使能
重新启用已禁用的 XOP 成员。

无效 XopENABLE（XOP *xop，其中）

XOPENTRY
返回 XOP 结构的成员。 这 是一个 cpp 令牌，指示哪个条目
返回。 如果未设置成员，这将返回一个默认值。 回报
类型取决于 这. 这个宏不止一次地评估它的参数。 如果你
正在使用“Perl_custom_op_xop”从“OP *”中检索“XOP *”，使用更多
取而代之的是高效的“XopENTRYCUSTOM”。

XopENTRY(XOP *xop, 其中)

XopenENTRYCUSTOM
就像“XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_ o), which)”但更多
高效的。 这 这 参数与“XopENTRY”相同。

XopENTRYCUSTOM(const OP *o,which)

XopENTRY_set
设置 XOP 结构的成员。 这 是一个 cpp 令牌，指示哪个条目
放。 有关可用成员的详细信息，请参阅 perlguts 中的“自定义运算符”
以及如何使用它们。 这个宏不止一次评估它的参数。

void XopENTRY_set(XOP *xop,which,值)

Xop标志
返回 XOP 的标志。

U32 XopFLAGS(XOP *xop)

CV 操作 功能

本节记录了操作 CV 的函数，这些 CV 是代码值或子例程。
有关更多信息，请参阅 perlguts。

来电者_cx
XSUB-writer 相当于 呼叫者（）. 返回的“PERL_CONTEXT”结构
可以查询以查找“调用者”返回给 Perl 的所有信息。
请注意，XSUB 不会获得堆栈帧，因此“caller_cx(0, NULL)”将返回
紧邻 Perl 代码的信息。

此函数跳过代表对象对 &DB::sub 的自动调用
调试器。 如果请求的堆栈帧是由“DB::sub”调用的子，则返回
value 将是调用“DB::sub”的框架，因为它有正确的行
号码/等为呼叫站点。 如果 数据库 是非“NULL”，它将被设置为
指向子调用本身的帧的指针。

常量 PERL_CONTEXT * caller_cx(
I32级，
常量 PERL_CONTEXT **dbcxp
)

CvSTASH 返回 CV 的存储。 stash 是符号表哈希，包含
定义子例程的包中的包范围变量。 为了
更多信息，请参见 perlguts。

这对于 XS AUTOLOAD 低音炮也有特殊用途。 请参阅“使用 XSUB 自动加载”
在perlguts。

HV* CvSTASH(CV* cv)

查找runcv
找到与当前执行的 sub 或 eval 对应的 CV。 如果 db_seqp 是
non_null，跳过 DB 包中的 CV 并使用 cop 填充 *db_seqp
输入 DB:: 代码时的序列号。 （这允许
调试器在断点范围内而不是在断点范围内进行评估
调试器本身。）

CV* find_runcv(U32 *db_seqp)

get_cv 使用“strlen”获取“name”的长度，然后调用“get_cvn_flags”。

注意：不推荐使用此函数的 perl_ 形式。

CV* get_cv(const char* 名称，I32 标志)

获取cvn标志
返回指定 Perl 子例程的 CV。 “标志”被传递给
“gv_fetchpvn_flags”。 如果设置了“GV_ADD”并且 Perl 子程序不存在
然后它将被声明（这与说“子名称；”具有相同的效果）。 如果
“GV_ADD”未设置且子程序不存在，则返回NULL。

注意：不推荐使用此函数的 perl_ 形式。

CV* get_cvn_flags(const char* 名称，STRLEN len，
I32 标志）

调试 实用工具

全部转储
将当前程序的整个 optree 从“PL_main_root”开始转储到
“STDERR”。 还转储“PL_defstash”中所有可见子程序的 opttree。

无效转储全部（）

转储_packsubs
转储“stash”中所有可见子程序的 opttree。

void dump_packsubs(const HV* 存储)

op_dump 将 optree 从 OP "o" 开始转储到 "STDERR"。

无效 op_dump（常量 OP *o）

sv_dump 将 SV 的内容转储到“STDERR”文件句柄。

有关其输出的示例，请参阅 Devel::Peek。

无效 sv_dump(SV* sv)

屏 显： 和 倾倒 功能

光伏显示
像

pv_escape（dsv、pv、cur、pvlim、PERL_PV_ESCAPE_QUOTE）；

除了当 len > cur 和
pv[cur] 是“\0”。

请注意，最终字符串最多可能比 pvlim 长 7 个字符。

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

光伏逃逸
最多转义 pv 的第一个“计数”字符并将结果放入 dsv 中，例如
转义字符串的大小不会超过“最大”字符并且不会
包含任何不完整的转义序列。 转义的字节数将为
如果它不为空，则在 STRLEN *escaped 参数中返回。 当 dsv
参数为 null 没有转义实际发生，但字节数
被转义，如果它不为空将被计算。

如果 flags 包含 PERL_PV_ESCAPE_QUOTE 那么字符串中的任何双引号都会
也能逃过一劫。

通常在准备转义字符串之前 SV 将被清除，但是当
PERL_PV_ESCAPE_NOCLEAR 设置这不会发生。

如果设置了 PERL_PV_ESCAPE_UNI，则输入字符串将被视为 UTF-8，如果
PERL_PV_ESCAPE_UNI_DETECT 被设置，然后输入字符串被扫描使用
"is_utf8_string()" 来确定它是否是 UTF-8。

如果设置了 PERL_PV_ESCAPE_ALL，则所有输入字符都将使用“\x01F1”输出
样式转义，否则如果设置了 PERL_PV_ESCAPE_NONASCII，则只有非 ASCII 字符
将使用这种风格进行转义； 否则，只有 255 以上的字符才会如此
逃过一劫； 其他不可打印的字符将使用八进制或常见的转义模式，如
“\n”。 否则，如果 PERL_PV_ESCAPE_NOBACKSLASH 那么所有低于 255 的字符都将是
被视为可打印，并将作为文字输出。

如果设置了 PERL_PV_ESCAPE_FIRSTCHAR，则只有字符串的第一个字符是
逃脱，无论最大值。 如果输出是十六进制，那么它将是
作为普通的十六进制序列返回。 因此输出将是单个字符，
八进制转义序列，特殊转义，如“\n”或十六进制值。

如果 PERL_PV_ESCAPE_RE 被设置，那么使用的转义字符将是一个 '%' 而不是一个
'\\'。 这是因为正则表达式经常包含反斜杠序列，而
'%' 不是模式中特别常见的字符。

返回指向 dsv 保存的转义文本的指针。

char* pv_escape(SV *dsv, char const * const str,
const STRLEN 计数，const STRLEN 最大值，
STRLEN * const 转义，
const U32 标志）

pv_漂亮
将字符串转换为可展示的内容，通过处理转义 pv_escape() 函数
并支持引用和省略号。

如果设置了 PERL_PV_PRETTY_QUOTE 标志，则结果将用双引号引起来
字符串中的任何双引号都被转义了。 否则如果 PERL_PV_PRETTY_LTGT
标志被设置然后结果被包裹在尖括号中。

如果设置了 PERL_PV_PRETTY_ELLIPSES 标志并且不是字符串中的所有字符都
输出然后省略号“...”将附加到字符串。 请注意，这
发生在它被引用之后。

如果 start_color 是非空的，那么它将被插入到开头的引号之后（如果
有一个）但在转义文本之前。 如果 end_color 为非空，那么它将
插入在转义文本之后但在任何引号或省略号之前。

返回一个指向 dsv 保存的美化文本的指针。

char* pv_pretty(SV *dsv, char const * const str,
const STRLEN 计数，const STRLEN 最大值，
char const * const start_color,
char const * const end_color，
const U32 标志）

嵌入 功能

简历克隆
克隆一个 CV，制作一个词法闭包。 原 提供原型
功能：它的代码、pad结构和其他属性。 原型是
结合对代码所指的外部词法的捕获，它们是
取自紧邻代码的当前正在执行的实例。

简历 * cv_clone(简历 *proto)

cv_name 返回一个包含简历名称的 SV，主要用于错误报告。
CV 实际上可能是 GV，在这种情况下，返回的 SV 包含 GV
名称。 除了 GV 或 CV 之外的任何东西都被视为已经包含
子名称，但这在未来可能会改变。

SV 可以作为第二个参数传递。 如果是这样，名称将被分配给它
它会被退回。 否则返回的SV将是一个新的凡人。

如果 标志 包含 CV_NAME_NOTQUAL，则不会包含包名称。
如果第一个参数既不是 CV 也不是 GV，则忽略此标志（取决于
改变）。

SV * cv_name(CV *cv, SV *sv, U32 标志)

CV_undef
清除 CV 的所有活动组件。 这可以通过
显式“undef &foo”，或者通过引用计数变为零。 在前者
在这种情况下，我们保留 CvOUTSIDE 指针，以便任何匿名孩子仍然可以
遵循完整的词法作用域链。

无效 cv_undef(CV* cv)

查找rundefsv
在词法范围内查找并返回名为 $_ 的变量
当前正在执行的函数。 这可能是一个词法 $_，否则将是
全球之一。

SV * find_rundefsv()

find_rundefsvoffset
已弃用！ 计划从 Perl 的未来版本中删除此功能。
不要将它用于新代码； 从现有代码中删除它。

查找词法 $_ 在当前执行的 pad 中的位置
功能。 返回当前焊盘中的偏移量，如果没有，则返回“NOT_IN_PAD”
范围内的词法 $_ （在这种情况下，应该使用全局变量）。
“find_rundefsv”可能更方便。

注意：不推荐使用此函数的 perl_ 形式。

PADOFFSET find_rundefsvoffset()

介绍_我的
“引入”“我的”变量到可见状态。 这在解析过程中被调用
每条语句的结尾使词法变量对后续的可见
声明。

U32 intro_my()

加载模块
加载名称由 name 的字符串部分指向的模块。 注意
应该给出实际的模块名称，而不是它的文件名。 例如，改为“Foo::Bar”
的“Foo/Bar.pm”。 标志可以是 PERL_LOADMOD_DENY、PERL_LOADMOD_NOIMPORT 或
PERL_LOADMOD_IMPORT_OPS（或 0 表示没有标志）。 ver，如果指定且不为NULL，
提供类似于“使用 Foo::Bar VERSION”的版本语义。 可选的
尾随 SV* 参数可用于指定模块的参数 进口（）
方法，类似于“使用 Foo::Bar VERSION LIST”。 它们必须以
最终空指针。 请注意，此列表只能在以下情况下省略
已使用 PERL_LOADMOD_NOIMPORT 标志。 否则至少有一个 NULL
需要指定默认导入列表的指针。

每个指定的“SV*”参数的引用计数递减。

void load_module(U32 标志，SV* 名称，SV* 版本，...)

新的PADNAMELIST
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

创建一个新的打击垫名称列表。 “max”是空间的最高索引
已分配。

PADNAMELIST * newPADNAMELIST(size_t max)

新PADNAME外层
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

构造并返回一个新的焊盘名称。 仅将此功能用于名称
参考外部词汇。 （另见“newPADNAMEpvn”。） 外 是外垫名称
这一个镜像。 返回的焊盘名称已经具有 PADNAMEt_OUTER 标志
设置。

PADNAME * newPADNAMEouter(PADNAME *outer)

新的PADNAMEpvn
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

构造并返回一个新的焊盘名称。 s 必须是 UTF8 字符串。 不要使用这个
用于指向外部词法的填充名称。 请参阅“newPADNAMEouter”。

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

无线程挂钩
在没有线程时为 perl_destruct 提供线程钩子的存根。

int nothreadhook()

padnamelist_fetch
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

从给定的索引中获取焊盘名称。

PADNAME * padnamelist_fetch(PADNAMELIST *pnl,
SSize_t 键）

padnamelist_store
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将焊盘名称（可能为空）存储在给定的索引处，释放任何现有的
该插槽中的焊盘名称。

PADNAME ** padnamelist_store(PADNAMELIST *pnl,
SSize_t 键，PADNAME *val)

垫_添加_匿名
在当前编译的 pad 中分配一个位置（通过“pad_alloc”）用于
在当前编译中的词法范围内的匿名函数
功能。 功能 FUNC 链接到垫中，其“CvOUTSIDE”链接到
外部范围被削弱以避免引用循环。

一个引用计数被盗，因此您可能需要执行“SvREFCNT_inc(func)”。

类型 应该是一个操作码，指示填充条目的操作类型
支持。 这不会影响操作语义，但用于调试。

PADOFFSET pad_add_anon(CV *func, I32 optype)

pad_add_name_pv
与“pad_add_name_pvn”完全一样，但采用以空字符结尾的字符串而不是
字符串/长度对。

PADOFFSET pad_add_name_pv(const char *name，U32 标志，
HV *typestash，HV *ourstash）

pad_add_name_pvn
在当前编译的 pad 中为命名的词法变量分配一个位置。
将名称和其他元数据存储在打击垫的名称部分，并使
准备管理变量的词法范围。 返回偏移量
分配的焊盘槽。

名称pv/名字 指定变量的名称，包括前导符号。 如果 打字机
非空，名称用于类型化词法，这标识了类型。 如果
我们的藏匿处 非空，它是对包变量的词法引用，这
标识包。 可以将以下标志组合在一起：

padadd_OUR 冗余地指定它是否是一个包变量
padadd_STATE 变量将永久保留值
padadd_NO_DUP_CHECK 跳过词法阴影检查

PADOFFSET pad_add_name_pvn(const char *namepv,
STRLEN namelen，U32 标志，
HV *typestash，HV *ourstash）

pad_add_name_sv
与“pad_add_name_pvn”完全一样，但采用SV形式的名称字符串
而不是字符串/长度对。

PADOFFSET pad_add_name_sv(SV *名称, U32 标志,
HV *typestash，HV *ourstash）

垫分配
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在当前编译的 pad 中分配一个位置，返回
分配的焊盘槽。 最初没有名称附加到打击垫插槽。 类型 是一个
指示所需填充输入类型的标志集，将在
分配的填充条目的值 SV：

SVs_PADMY 命名词法变量 ("my", "our", "state")
SVs_PADTMP 未命名的临时存储
SVf_READONLY 在递归级别之间共享的常量

仅从 perl 5.20 开始支持“SVf_READONLY”。 与更早的合作
版本也一样，使用“SVf_READONLY|SVs_PADTMP”。 “SVf_READONLY”不会导致
pad 插槽中的 SV 被标记为只读，但只是告诉“pad_alloc”
it 将 被设为只读（由调用者），或者至少应该被这样对待。

类型 应该是一个操作码，指示填充条目的操作类型
支持。 这不会影响操作语义，但用于调试。

PADOFFSET pad_alloc（I32 optype，U32 tmptype）

pad_findmy_pv
与“pad_findmy_pvn”完全一样，但采用以空字符结尾的字符串而不是
字符串/长度对。

PADOFFSET pad_findmy_pv(const char *name, U32 标志)

pad_findmy_pvn
给定一个词法变量的名称，找到它在当前编译中的位置
软垫。 名称pv/名字 指定变量的名称，包括前导符。 标志
保留且必须为零。 如果它不在当前打击垫中但出现在
填充任何词法封闭作用域，然后将其伪条目添加到
当前垫。 返回当前焊盘中的偏移量，如果没有，则返回“NOT_IN_PAD”
词法在范围内。

PADOFFSET pad_findmy_pvn(const char *namepv,
STRLEN 名称，U32 标志）

pad_findmy_sv
与“pad_findmy_pvn”完全一样，但采用SV形式的名称字符串
而不是字符串/长度对。

PADOFFSET pad_findmy_sv(SV *名称, U32 标志)

pad_setsv
在偏移处设置值 po 在当前（编译或执行）pad 中。 使用
宏 PAD_SETSV() 而不是直接调用这个函数。

void pad_setsv(PADOFFSET po, SV *sv)

pad_sv 获取偏移量处的值 po 在当前（编译或执行）pad 中。 使用宏
PAD_SV 而不是直接调用这个函数。

SV * pad_sv(PADOFFSET po)

垫整齐
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在它所属的代码编译结束时整理一个 pad。 工作
这里执行的是：从 anonsub 原型的焊盘上移除大部分东西； 给它
一个 @_; 将临时对象标记为此类。 类型 表示子程序的种类：

padtidy_SUB 普通子程序
padtidy_SUBCLONE 词法闭包原型
padtidy_FORMAT 格式

void pad_tidy(padtidy_type 类型)

perl_alloc
分配一个新的 Perl 解释器。 见迷惑。

Perl解释器* perl_alloc()

perl_构造
初始化一个新的 Perl 解释器。 见迷惑。

无效 perl_construct(PerlInterpreter *my_perl)

perl_destruct
关闭 Perl 解释器。 见迷惑。

int perl_destruct(PerlInterpreter *my_perl)

perl_free
发布 Perl 解释器。 见迷惑。

无效 perl_free(PerlInterpreter *my_perl)

perl_parse
告诉 Perl 解释器解析 Perl 脚本。 见迷惑。

int perl_parse(PerlInterpreter *my_perl,
XSINIT_t xsinit，int argc，
字符** argv，字符** 环境）

perl_运行
告诉 Perl 解释器运行。 见迷惑。

int perl_run(PerlInterpreter *my_perl)

需要_pv
告诉 Perl “要求”由字符串参数命名的文件。 它类似于
Perl 代码“eval”需要‘$file’”。 它甚至是这样实现的； 考虑
使用 load_module 代替。

注意：不推荐使用此函数的 perl_ 形式。

无效 require_pv(const char* pv)

特殊课程 处理 （简单的） 宏

dXCPT 为异常处理设置必要的局部变量。 参见“异常处理”
在perlguts。

dXCPT；

XCPT_CATCH
引入一个 catch 块。 请参阅 perlguts 中的“异常处理”。

XCPT_RETHROW
重新抛出先前捕获的异常。 请参阅 perlguts 中的“异常处理”。

XCPT_RETHROW；

XCPT_TRY_END
结束一个 try 块。 请参阅 perlguts 中的“异常处理”。

XCPT_TRY_START
启动一个 try 块。 请参阅 perlguts 中的“异常处理”。

全球覆盖 变量

这些变量对于整个过程是全局的。 它们在所有口译员之间共享
以及进程中的所有线程。

PL_检查
将在“检查”阶段调用的函数数组，由操作码索引
在编译 Perl 代码期间构建 optree。 对于大多数（但不是全部）类型
的 op，一旦 op 被最初构建并填充了子操作，它将
通过适当元素引用的检查函数过滤
这个数组。 新操作作为检查函数的唯一参数传入，
并且检查函数返回完成的操作。 检查功能可以（作为
顾名思义）检查操作的有效性和信号错误。 它也可能
初始化或修改部分操作，或执行更彻底的手术，例如
添加或删除子操作，甚至丢弃操作并返回不同的操作
在它的位置。

这个函数指针数组是挂钩到编译的方便位置
过程。 XS 模块可以用自己的自定义检查函数代替任何
标准的，以影响特定类型操作的编译。
但是，自定义检查功能绝不能完全替代标准检查
函数（甚至是来自另一个模块的自定义检查函数）。 一个模块
修改检查必须改为 包装 预先存在的检查功能。 一个习俗
check 函数必须选择何时应用其自定义行为。 在里面
通常情况下，它决定不对操作做任何特殊的事情，它必须链接
预先存在的 op 函数。 检查功能因此链接在一个链中，与
最后是核心的基础检查器。

为了线程安全，模块不应直接写入此数组。 相反，使用
函数“wrap_op_checker”。

PL_关键字_插件
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

函数指针，指向用于处理扩展关键字的函数。 这
函数应声明为

int 关键字插件函数（pTHX_
字符 *keyword_ptr，STRLEN 关键字_len，
操作 **op_ptr)

只要看到可能的关键字，就会从标记器调用该函数。
“keyword_ptr”指向解析器输入缓冲区中的单词，“keyword_len”
给出它的长度； 它不是以空值结尾的。 该功能预计将检查
这个词，可能还有其他状态，例如 %^H，来决定它是否想要
将其作为扩展关键字处理。 如果没有，函数应该返回
“KEYWORD_PLUGIN_DECLINE”，然后正常的解析器进程将继续。

如果函数想要处理关键字，它首先必须解析任何东西
跟在关键字引入的语法的一部分的关键字之后。 看
“词法分析器界面”了解详细信息。

处理关键字时，插件函数必须构建“OP”树
结构，表示已解析的代码。 树的根必须是
存储在 *op_ptr 中。 然后该函数返回一个表示语法的常量
它已解析的构造的角色：“KEYWORD_PLUGIN_STMT”，如果它是
完整的语句，如果是表达式，则为“KEYWORD_PLUGIN_EXPR”。 请注意，一个
语句构造不能在表达式中使用（通过“do BLOCK”和
类似），并且表达式不是完整的语句（它至少需要一个
结束分号）。

处理关键字时，插件函数也可能有（编译时）端
效果。 它可以修改“%^H”，定义函数等等。 通常，如果侧
效果是处理程序的主要目的，它不希望生成任何操作
包含在正常编译中。 在这种情况下，仍然需要
提供一个操作树，但它足以生成一个空操作。

这就是 *PL_keyword_plugin 函数需要整体表现的方式。
然而，传统上，并没有完全取代现有的处理程序
功能。 相反，在分配您自己的之前复制“PL_keyword_plugin”
指向它的函数指针。 你的处理函数应该寻找它的关键字
感兴趣并处理这些。 如果它不感兴趣，它应该调用
保存的插件函数，传递它收到的参数。 因此
“PL_keyword_plugin”实际上指向一个处理函数链，所有这些函数
有机会处理关键字，并且只有链中的最后一个函数
（内置在 Perl 核心中）通常会返回“KEYWORD_PLUGIN_DECLINE”。

GV 功能

GV 是对应于 Perl typeglob 的结构，即 *foo。 它是一个结构
它包含一个指向标量、数组、哈希等的指针，对应于 $foo、@foo、%foo。

GV 通常作为值在 Perl 存储它的 stashes（符号表哈希）中找到
全局变量。

GvAV 从 GV 返回 AV。

AV* GvAV(GV* gv)

GvCV 从 GV 返回 CV。

CV* GvCV(GV* gv)

GvHV 从 GV 返回 HV。

高压* GvHV(GV* gv)

GvSV 从 GV 返回 SV。

SV* GvSV(GV* gv)

gv_const_sv
如果“gv”是一个 typeglob，其子例程条目是一个常量 sub 符合条件
内联，或“gv”是一个占位符引用，将被提升为这样的
typeglob，然后返回子返回的值。 否则，返回 NULL。

SV* gv_const_sv(GV* gv)

gv_fetchmeth
与“gv_fetchmeth_pvn”类似，但缺少标志参数。

GV* gv_fetchmeth(HV* stash, const char* 名称,
STRLEN len，I32 级）

gv_fetchmethod_autoload
返回包含要调用以调用方法的子例程的 glob
“藏”。 事实上，在存在自动加载的情况下，这可能是
“自动加载”。 在这种情况下，已经设置了相应的变量 $AUTOLOAD。

“gv_fetchmethod_autoload”的第三个参数决定是否AUTOLOAD
如果给定方法不存在，则执行查找：非零表示是，看
用于自动加载； 零表示不，不要寻找AUTOLOAD。 调用“gv_fetchmethod”是
相当于用非零“自动加载”调用“gv_fetchmethod_autoload”
参数。

这些函数授予“SUPER”标记作为方法名称的前缀。 请注意，如果
您想长时间保留返回的 glob，您需要检查它是否存在
“AUTOLOAD”，因为稍后调用可能会加载不同的子程序
到 $AUTOLOAD 更改其值。 使用作为副作用创建的 glob 来做
本。

这些函数与带有“level==0”的“gv_fetchmeth”具有相同的副作用。 这
警告不要将“gv_fetchmeth”返回的 GV 传递给“call_sv”
同样适用于这些功能。

GV* gv_fetchmethod_autoload(HV* 存储,
const char* 名称，
I32 自动加载）

gv_fetchmeth_autoload
这是“gv_fetchmeth_pvn_autoload”的旧形式，它没有标志参数。

GV* gv_fetchmeth_autoload(HV* 存储,
const char* 名称，
STRLEN len，I32 级）

gv_fetchmeth_pv
与 "gv_fetchmeth_pvn" 完全一样，但采用一个以 nul 结尾的字符串而不是
字符串/长度对。

GV* gv_fetchmeth_pv(HV* stash, const char* 名称,
I32 级别，U32 标志）

gv_fetchmeth_pvn
返回具有给定“名称”和已定义子例程或“NULL”的 glob。 这
glob 存在于给定的“stash”中，或者可以通过@ISA 访问的 stash 和
普遍的：：。

参数“级别”应该是 0 或 -1。 如果“level==0”，作为副作用
在给定的“stash”中创建一个具有给定“name”的glob，在这种情况下
成功包含子例程的别名，并为此设置缓存信息
球。

“标志”的唯一重要值是 GV_SUPER 和 SVf_UTF8。

GV_SUPER 表示我们要查找超类中的方法
“藏”。

“gv_fetchmeth”返回的 GV 可能是方法缓存项，不是
Perl 代码可见。 所以在调用“call_sv”时，不应该使用GV
直接地; 相反，您应该使用方法的 CV，它可以从
带有“GvCV”宏的 GV。

GV* gv_fetchmeth_pvn(HV* stash, const char* 名称,
STRLEN len，I32 级，
U32 标志）

gv_fetchmeth_pvn_autoload
与...一样 gv_fetchmeth_pvn()，但也会查找自动加载的子例程。 返回一个
子程序的 glob。

对于没有 GV 的自动加载子程序，即使“级别 < 0”也会创建 GV。
对于没有存根的自动加载子例程， CVCV() 结果可能为零。

目前，“标志”的唯一重要值是 SVf_UTF8。

GV* gv_fetchmeth_pvn_autoload(HV* 藏匿，
const char* 名称，
STRLEN len，I32 级，
U32 标志）

gv_fetchmeth_pv_autoload
与 "gv_fetchmeth_pvn_autoload" 完全一样，但需要一个以 nul 结尾的字符串
而不是字符串/长度对。

GV* gv_fetchmeth_pv_autoload(HV* 存储,
const char* 名称，
I32 级别，U32 标志）

gv_fetchmeth_sv
与“gv_fetchmeth_pvn”完全一样，但采用 SV 形式的名称字符串
而不是字符串/长度对。

GV* gv_fetchmeth_sv(HV* 存储, SV* 名称v,
I32 级别，U32 标志）

gv_fetchmeth_sv_autoload
与 "gv_fetchmeth_pvn_autoload" 完全一样，但名称字符串的形式为
SV 而不是字符串/长度对。

GV* gv_fetchmeth_sv_autoload(HV* 存储, SV* namesv,
I32 级别，U32 标志）

gv_init 的旧形式 gv_init_pvn(). 它不适用于 UTF8 字符串，因为它没有
标志参数。 如果设置了“multi”参数，则 GV_ADDMULTI 标志将为
传递给 gv_init_pvn().

void gv_init(GV* gv, HV* stash, const char* 名称,
STRLEN len，int 多）

gv_init_pv
与...一样 gv_init_pvn(), 但使用一个以 nul 结尾的字符串作为名称而不是
单独的 char * 和长度参数。

void gv_init_pv(GV* gv, HV* stash, const char* 名称,
U32 标志）

gv_init_pvn
将标量转换为类型团。 这是一个不可强制的 typeglob； 分配一个
对它的引用将分配给它的插槽之一，而不是将其覆盖为
发生在 SvSetSV 创建的 typeglob 上。 转换任何标量 OK()
可能会产生不可预知的结果，并保留给 perl 的内部使用。

“gv”是要转换的标量。

“stash”是父存储/包，如果有的话。

“name”和“len”给出了名称。 名称必须不合格； 也就是说，它必须
不包括包名。 如果“gv”是一个隐藏元素，它是调用者的
有责任确保传递给此函数的名称与
元素。 如果不匹配，perl 的内部簿记将退出
同步。

如果 "name" 是 UTF8 字符串，则 "flags" 可以设置为 SVf_UTF8，或者返回值
SVUTF8(sv)。 它还可以带 GV_ADDMULTI 标志，这意味着假装
GV 以前曾见过（即，禁止“使用一次”警告）。

void gv_init_pvn(GV* gv, HV* stash, const char* 名称,
STRLEN len，U32 标志）

gv_init_sv
与...一样 gv_init_pvn(), 但使用 SV * 作为名称而不是单独的 char *
和长度参数。 “标志”当前未使用。

void gv_init_sv(GV* gv, HV* 存储, SV* 名称,
U32 标志）

gv_stashpv
返回指向指定包的存储的指针。 使用“strlen”
确定“name”的长度，然后调用“gv_stashpvn()”。

HV* gv_stashpv(const char* 名称，I32 标志)

gv_stashpvn
返回指向指定包的存储的指针。 “namelen”参数
表示“名称”的长度，以字节为单位。 “标志”被传递给
“gv_fetchpvn_flags()”，所以如果设置为“GV_ADD”，那么如果
它还不存在。 如果包不存在且“标志”为 0（或任何
其他不创建包的设置），则返回 NULL。

标志可能是以下之一：

GV_ADD
SVf_UTF8
GV_NOADD_NOINIT
GV_NOINIT
GV_NOEXPAND
GV_ADDMG

其中最重要的可能是 GV_ADD 和 SVf_UTF8。

请注意，在可能的情况下强烈使用“gv_stashsv”而不是“gv_stashpvn”
出于性能原因推荐。

HV* gv_stashpvn(const char* 名称, U32 namelen,
I32 标志）

gv_stashpvs
与“gv_stashpvn”类似，但采用文字字符串而不是字符串/长度对。

HV* gv_stashpvs（const char* 名称，I32 创建）

gv_stashsv
返回指向指定包的存储的指针。 参见“gv_stashpvn”。

请注意，在性能方面，此接口优于“gv_stashpvn”
原因。

HV* gv_stashsv（SV* sv，I32 标志）

设置默认值
将输出的默认文件句柄 PL_defoutgv 设置为传入的 typeglob。
由于 PL_defoutgv 在其 typeglob 上“拥有”一个引用，所以它的引用计数
传入的typeglob加一，typeglob的引用计数
PL_defoutgv 指向的减一。

无效 setdefout(GV* gv)

便利 理念

Nullav Null AV 指针。

（已弃用 - 改用“(AV *)NULL”）

Nullch 空字符指针。 （定义“PERL_CORE”时不再可用。）

Nullcv 空 CV 指针。

（已弃用 - 改用“（CV *）NULL”）

Nullhv 空 HV 指针。

（已弃用 - 改用“(HV *)NULL”）

Nullsv Null SV 指针。 （定义“PERL_CORE”时不再可用。）

哈希 操作 功能

一个 HV 结构代表一个 Perl 哈希。 它主要由一个指针数组组成，每个指针
其中指向 HE 结构的链表。 该数组由哈希索引
键的函数，因此每个链表代表所有具有相同的哈希条目
哈希值。 每个 HE 包含一个指向实际值的指针，以及一个指向 HEK 的指针
保存键和哈希值的结构。

警察获取标签
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

返回附在警察身上的标签。 标志指针可以设置为“SVf_UTF8”
或0。

const char * cop_fetch_label(COP *const cop,
STRLEN *len，U32 *标志）

警察商店标签
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将标签保存到“cop_hints_hash”中。 您需要将标志设置为“SVf_UTF8”
UTF-8 标签。

无效 cop_store_label（COP *const 警察，
const char *label，STRLEN len，
U32 标志）

get_hv 返回指定 Perl 散列的 HV。 “标志”被传递给“gv_fetchpv”。
如果设置了“GV_ADD”并且 Perl 变量不存在，那么它将被创建。
如果“flags”为零且变量不存在，则返回 NULL。

注意：不推荐使用此函数的 perl_ 形式。

HV* get_hv(const char *name, I32 标志)

HEf_SVKEY
该标志用于散列条目和魔术结构的长度槽，指定
该结构包含一个“SV*”指针，其中需要一个“char*”指针。
（仅供参考——请勿使用）。

HeHASH 返回存储在哈希条目中的计算哈希。

U32 HeHASH(他*他)

HeKEY 返回存储在哈希条目的键槽中的实际指针。 指针
可能是“char*”或“SV*”，具体取决于“HeKLEN()”的值。 可
分配给。 “HePV()”或“HeSVKEY()”宏通常更适合于
找到一个键的值。

void* HeKEY(HE* he)

HeKLEN 如果为负数，等于“HEf_SVKEY”，则表明该条目持有
“SV*”键。 否则，保存密钥的实际长度。 可以分配给。
“HePV()”宏通常更适合查找密钥长度。

STRLEN HeKLEN(他*他)

HePV 将哈希条目的键槽作为“char*”值返回，执行任何必要的操作
取消引用可能的“SV *”键。 字符串的长度放在“len”中
（这是一个宏，所以这样做 而不去 使用 &len)。 如果你不在乎什么长度
关键是，您可以使用全局变量“PL_na”，尽管这要少得多
比使用局部变量更有效。 不过请记住，perl 中的哈希键
可以自由包含嵌入的空值，因此使用“strlen()”或类似的不是一个好方法
查找哈希键长度的方法。 这与“SvPV()”宏非常相似
本文档其他地方描述。 另见“HeUTF8”。

如果您使用“HePV”获取要传递给“newSVpvn()”的值以创建新的 SV，
您应该考虑使用“newSVhek(HeKEY_hek(he))”，因为它更有效。

char* HePV(HE* he, STRLEN len)

HeSVKEY 将键作为“SV*”返回，如果哈希条目不包含“SV*”，则返回“NULL”
键。

SV* HeSVKEY(HE* he)

HeSVKEY_force
将密钥作为“SV*”返回。 将创建并返回一个临时的凡人“SV*”，如果
哈希条目仅包含一个“char*”键。

SV* HeSVKEY_force(HE* he)

HeSVKEY_set
将密钥设置为给定的“SV*”，注意将适当的标志设置为
表示存在“SV*”键，并返回相同的“SV*”。

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

HeUTF8 返回“HePV”返回的“char *”值是否用UTF-8编码，做
对可能的“SV*”键进行任何必要的取消引用。 返回的值将为 0
或非 0，不一定是 1（甚至是设置了任何低位的值），所以 do 而不去
盲目地将其分配给“bool”变量，因为“bool”可能是“char”的typedef。

U32 HeUTF8(他*他)

HeVAL 返回存储在哈希条目中的值槽（类型“SV*”）。 可以分配给。

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

SV* HeVAL(HE* 他)

HvENAME 返回存储的有效名称，如果没有，则返回 NULL。 有效的
name 表示此存储所在的符号表中的位置。 它是
当包被别名或删除时自动更新。 一个不存在的藏匿处
符号表中不再有有效名称。 这个名字更可取
“HvNAME”用于 MRO 线性化和 isa 缓存。

char* HvENAME(HV* 存储)

蜗牛
返回存储的有效名称的长度。

STRLEN HvENAMELEN(HV *stash)

HvENAMEUTF8
如果有效名称采用 UTF8 编码，则返回 true。

无符号字符 HvENAMEUTF8(HV *stash)

HvNAME 返回存储的包名称，如果“stash”不是存储，则返回 NULL。 看
“SvSTASH”，“CvSTASH”。

char* HvNAME(HV* 存储)

名称
返回存储名称的长度。

STRLEN HvNAMELEN(HV *stash)

HvNAMEUTF8
如果名称采用 UTF8 编码，则返回 true。

无符号字符 HvNAMEUTF8(HV *stash)

hv_断言
检查哈希是否处于内部一致状态。

无效 hv_assert(HV *hv)

高压清除
释放哈希的所有元素，使其为空。 XS 相当于
“%hash = ()”。 另见“hv_undef”。

有关哈希在返回时可能无效的说明，请参见“av_clear”。

无效 hv_clear(HV *hv)

hv_clear_placeholders
从哈希中清除所有占位符。 如果受限制的散列有它的任何键
标记为只读并且密钥随后被删除，密钥实际上不是
已删除，但通过为其分配 &PL_sv_placeholder 的值来标记。 这标记它
因此它将被未来的操作（例如遍历哈希）忽略，但是
仍将允许哈希在将来某个时候重新分配给键的值
观点。 此函数从散列中清除任何此类占位符键。 看
哈希::Util::lock_keys() 举个例子。

无效 hv_clear_placeholders(HV *hv)

hv_copy_hints_hv
用于复制“%^H”的“newHVhv”的专用版本。 哦 必须是指向 a 的指针
哈希（可能有“%^H”魔法，但通常应该是非魔法的），或“NULL”
（解释为空哈希）。 的内容 哦 被复制到一个新的哈希值，它
添加了“%^H”特定的魔法。 返回指向新哈希的指针。

HV * hv_copy_hints_hv(HV *ohv)

hv_删除
删除散列中的键/值对。 值的 SV 从散列中移除，
成为凡人，并返回给调用者。 “klen”的绝对值是
密钥的长度。 如果“klen”为负数，则假定密钥在
UTF-8 编码的 Unicode。 “标志”值通常为零； 如果设置为
G_DISCARD 然后 NULL 将被返回。 如果键是 NULL 也将返回
没有找到。

SV* hv_delete(HV *hv, const char *key, I32 klen,
I32 标志）

hv_delete_ent
删除散列中的键/值对。 值 SV 从散列中删除，制成
凡人，并返回给调用者。 “标志”值通常为零； 如果
设置为 G_DISCARD 则返回 NULL。 如果
未找到密钥。 "hash" 可以是一个有效的预计算哈希值，也可以是 0 来请求
它被计算。

SV* hv_delete_ent(HV *hv, SV *keysv, I32 标志,
U32 哈希）

hv_存在
返回一个布尔值，指示指定的哈希键是否存在。 绝对的
“klen”的值是键的长度。 如果“klen”是负数，关键是
假定为 UTF-8 编码的 Unicode。

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

hv_exists_ent
返回一个布尔值，指示指定的哈希键是否存在。 “哈希”可以是
一个有效的预先计算的哈希值，或 0 要求计算它。

bool hv_exists_ent(HV *hv, SV *keysv, U32 哈希)

hv_fetch
返回与哈希中指定键对应的 SV。 绝对的
“klen”的值是键的长度。 如果“klen”是负数，关键是
假定为 UTF-8 编码的 Unicode。 如果设置了“lval”，那么获取将是
商店的一部分。 这意味着如果哈希中没有与
给定键，然后创建一个并返回指向它的指针。 “SV*”它
可以分配到的点。 但始终检查返回值是否为非空
在将其取消引用到“SV *”之前。

有关更多信息，请参阅 perlguts 中的“了解绑定哈希和数组的魔力”
有关如何在绑定哈希上使用此函数的信息。

SV** hv_fetch(HV *hv, const char *key, I32 klen,
I32 左值）

hv_fetchs
与“hv_fetch”类似，但采用文字字符串而不是字符串/长度对。

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

hv_fetch_ent
返回对应于哈希中指定键的哈希条目。 “哈希”
必须是给定“密钥”的有效预计算哈希数，如果需要，则为 0
函数来计算它。 如果设置了“lval”，则提取将成为存储的一部分。
在访问它之前确保返回值是非空的。 时的返回值
“hv”是一个绑定的哈希是一个指向静态位置的指针，所以一定要复制一份
如果您需要将其存储在某个地方，请查看该结构。

有关更多信息，请参阅 perlguts 中的“了解绑定哈希和数组的魔力”
有关如何在绑定哈希上使用此函数的信息。

HE* hv_fetch_ent(HV *hv, SV *keysv, I32 lval,
U32 哈希）

hv_fill 返回碰巧正在使用的哈希桶的数量。 这个功能是
由宏“HvFILL”包裹。

以前，这个值总是存储在 HV 结构中，它创建了一个
每个散列（以及几乎每个对象）的开销
很少使用。 现在我们在第一次需要时按需计算它，并且
如果重复该计算的成本很高，请将其缓存。 缓存值为
通过插入和删除更新，但（当前）如果散列被丢弃
分裂。

STRLEN hv_fill(HV *const hv)

hv_iterinit
准备遍历哈希表的起点。 返回键的数量
哈希（即与“HvUSEDKEYS(hv)”相同）。 返回值目前只有
对没有 tie 魔法的哈希有意义。

注意：在 5.004_65 版本之前，“hv_iterinit”用于返回哈希数
碰巧正在使用的存储桶。 如果你仍然需要那个深奥的价值，你可以
通过宏“HvFILL(hv)”得到它。

I32 hv_iterinit(HV *hv)

hv_iterkey
从哈希迭代器的当前位置返回键。 看
“hv_iterinit”。

char* hv_iterkey(HE* 条目, I32* retlen)

hv_iterkeysv
从哈希迭代器的当前位置返回键作为“SV*”。 这
返回值将始终是密钥的凡人副本。 另请参阅“hv_iterinit”。

SV* hv_iterkeysv（HE* 条目）

hv_iternext
从哈希迭代器返回条目。 请参阅“hv_iterinit”。

您可以在迭代器的哈希条目上调用“hv_delete”或“hv_delete_ent”
当前指向，而不会丢失您的位置或使您的迭代器无效。
请注意，在这种情况下，当前条目将使用您的哈希值从散列中删除
持有对它的最后引用的迭代器。 您的迭代器被标记为释放
下一次调用“hv_iternext”时的条目，所以你不能丢弃你的迭代器
否则条目将立即泄漏 - 调用“hv_iternext”来触发资源
解除分配。

HE* hv_iternext(HV *hv)

hv_iternextsv
在一次操作中执行“hv_iternext”、“hv_iterkey”和“hv_iterval”。

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

hv_iternext_flags
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

从哈希迭代器返回条目。 参见“hv_iterinit”和“hv_iternext”。 这
“flags”值通常为零； 如果设置了 HV_ITERNEXT_WANTPLACEHOLDERS
除了正常之外，还将返回占位符键（用于受限哈希）
键。 默认情况下，占位符会自动跳过。 目前一个
占位符是用 &PL_sv_placeholder 的值实现的。 请注意，
占位符和受限哈希的实现可能会发生变化，并且
目前的实现还不够抽象，无法使任何更改保持整洁。

HE* hv_iternext_flags（HV *hv，I32 标志）

hv_iterval
从哈希迭代器的当前位置返回值。 看
“hv_iterkey”。

SV* hv_iterval(HV *hv, HE *条目)

hv_magic
为哈希添加魔法。 参见“sv_magic”。

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

hv_标量
在标量上下文中评估哈希并返回结果。 处理魔法时
哈希是绑定的。

SV* hv_标量(HV *hv)

hv_商店
将 SV 存储在哈希中。 哈希键被指定为“key”和绝对值
“klen”的长度是密钥的长度。 如果“klen”为负，则假定密钥为
采用 UTF-8 编码的 Unicode。 “hash”参数是预计算的哈希值；
如果它为零，那么 Perl 将计算它。

如果操作失败或该值不需要，则返回值将为 NULL
实际存储在散列中（如绑定散列的情况）。 否则
它可以被取消引用以获得原始的“SV *”。 请注意，调用者是
负责适当增加“val”的引用计数之前
调用，如果函数返回 NULL，则将其递减。 有效地成功
hv_store 拥有对“val”的一个引用的所有权。 这通常是你
想; 新创建的 SV 的引用计数为 XNUMX，因此如果您的所有代码都是
创建 SV 然后将它们存储在哈希中，hv_store 将拥有对
新的 SV，你的代码不需要做任何进一步的整理。 hv_store 是
未实现为对 hv_store_ent 的调用，并且不会为
密钥，因此如果您的密钥数据尚未采用 SV 形式，则使用 hv_store in
偏好 hv_store_ent。

有关更多信息，请参阅 perlguts 中的“了解绑定哈希和数组的魔力”
有关如何在绑定哈希上使用此函数的信息。

SV** hv_store(HV *hv, const char *key, I32 klen,
SV *val，U32 哈希）

hv_商店
与“hv_store”类似，但采用文字字符串而不是字符串/长度对
省略哈希参数。

SV** hv_stores(HV* tb，const char* 键，
NULLOK SV* 值）

hv_store_ent
将“val”存储在哈希中。 哈希键被指定为“key”。 “哈希”参数
是预先计算的哈希值； 如果它为零，那么 Perl 将计算它。 这
返回值是这样创建的新哈希条目。 如果操作将是 NULL
失败或者该值不需要实际存储在哈希中（如
绑定哈希的情况）。 否则返回值的内容可以是
使用“他？”访问此处描述的宏。 请注意，调用者是
负责适当增加“val”的引用计数之前
调用，如果函数返回 NULL，则将其递减。 有效地成功
hv_store_ent 拥有对“val”的一个引用。 这通常是你
想; 新创建的 SV 的引用计数为 XNUMX，因此如果您的所有代码都是
创建 SV 然后将它们存储在哈希中，hv_store 将拥有对
新的 SV，你的代码不需要做任何进一步的整理。 注意
hv_store_ent 只读取“key”； 与 "val" 不同，它不拥有它的所有权，
所以在“key”上保持正确的引用计数完全是调用者的
责任。 hv_store 没有作为对 hv_store_ent 的调用来实现，而是
不为密钥创建临时 SV，因此如果您的密钥数据尚未在 SV 中
然后使用 hv_store 优先于 hv_store_ent。

有关更多信息，请参阅 perlguts 中的“了解绑定哈希和数组的魔力”
有关如何在绑定哈希上使用此函数的信息。

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

hv_undef
取消定义哈希。 XS 等效于“undef(%hash)”。

以及释放散列的所有元素（如 hv_clear())，这也释放了
与散列相关的任何辅助数据和存储。

有关哈希在返回时可能无效的说明，请参见“av_clear”。

无效 hv_undef(HV *hv)

newHV 创建一个新的 HV。 引用计数设置为 1。

高压*新高压（）

钩 操纵

这些函数提供了操作钩子变量的方便和线程安全的方法。

包装操作检查器
将 C 函数放入指定操作类型的检查函数链中。 这
是操作“PL_check”数组的首选方式。 操作码 指定哪个
操作类型将受到影响。 新检查器 是指向 C 函数的指针
被添加到该操作码的检查链中，并且 旧检查器p 指向存储
指向链中下一个函数的指针将被存储的位置。 这
价值 新指针 被写入“PL_check”数组，而值
以前存储在那里被写入 *旧_检查器_p.

函数应该这样定义：

静态 OP *new_checker(pTHX_ OP *op) { ... }

它打算以这种方式调用：

new_checker（aTHX_op）

旧检查器p 应该这样定义：

静态 Perl_check_t old_checker_p;

“PL_check”对整个进程是全局的，并且是一个希望挂钩操作的模块
检查可能会发现自己在每个进程中多次调用，通常在
不同的线程。 为了处理这种情况，这个函数是幂等的。 这
！ *旧_检查器_p 必须最初（每个进程一次）包含一个空指针。
静态持续时间的 AC 变量（在文件范围内声明，通常也标记为
“静态”给它内部链接）将被隐式初始化
适当地，如果它没有明确的初始化程序。 该功能将
仅在找到时才实际修改检查链 *旧_检查器_p 为空。 这
函数在小范围内也是线程安全的。 它使用适当的锁定来
在访问“PL_check”时避免竞争条件。

当这个函数被调用时，被引用的函数 新检查器 必须准备好
被调用，除了 *旧_检查器_p 未满。 在线程情况下，
新检查器 可以立即调用，甚至在此函数返回之前。
*旧_检查器_p 将始终在之前适当设置 新检查器 叫做。 如果
新检查器 决定不对给定的操作做任何特别的事情（其中
是大多数操作检查挂钩的常见情况），它必须链接检查
引用的函数 *旧_检查器_p.

如果要影响对特定子例程的调用的编译，请使用
“cv_set_call_checker”而不是挂钩检查所有“entersub”操作。

void wrap_op_checker(Optype 操作码，
Perl_check_t new_checker,
Perl_check_t *old_checker_p)

词法分析器 接口

这是 Perl 解析器的较低层，管理字符和标记。

lex_bufutf8
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

指示词法分析器缓冲区（“PL_parser->linestr”）中的八位字节是否应该是
解释为 Unicode 字符的 UTF-8 编码。 如果没有，他们应该是
解释为 Latin-1 字符。 这类似于“SvUTF8”标志
标量。

在 UTF-8 模式下，不能保证词法分析器缓冲区实际上包含有效的
UTF-8。 面对无效编码，词法分析代码必须是健壮的。

“PL_parser->linestr”标量的实际“SvUTF8”标志很重要，但是
不是关于输入字符编码的全部内容。 通常，当一个文件
正在读取，标量包含八位字节并且它的“SvUTF8”标志是关闭的，但是
如果“use utf8”编译指示有效，八位字节应被解释为 UTF-8。
然而，在字符串 eval 期间，标量可能有“SvUTF8”标志，并且在
在这种情况下，它的八位字节应被解释为 UTF-8，除非“使用字节”编译指示
生效。 这种逻辑将来可能会改变； 使用此功能代替
自己实现逻辑。

布尔 lex_bufutf8()

lex_discard_to
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

丢弃“PL_parser->linestr”缓冲区的第一部分，最多 PTR。 该
缓冲区的剩余内容将被移动，并且所有指针都进入缓冲区
适当更新。 PTR 缓冲区中的位置不得晚于
“PL_parser->bufptr”：不允许丢弃尚未进行词法分析的文本。

通常不必直接执行此操作，因为使用
“lex_next_chunk”和基于它的事物的隐式丢弃行为。
但是，如果一个标记跨越多行，并且词法分析代码保持
为此目的，缓冲区中的多行文本，然后在完成后
明智的做法是明确丢弃现在不需要的早期行，
以避免未来的多行令牌无限制地增长缓冲区。

无效 lex_discard_to(char *ptr)

lex_grow_linestr
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

重新分配词法分析器缓冲区（“PL_parser->linestr”）以至少容纳 LEN
八位字节（包括终止“NUL”）。 返回指向重新分配的指针
缓冲。 在对缓冲区进行任何直接修改之前，这是必需的
这会增加它的长度。 “lex_stuff_pvn”提供了一种更方便的方式
将文本插入缓冲区。

不要在“PL_parser->linestr”上直接使用“SvGROW”或“sv_grow”； 这个函数
更新所有直接指向缓冲区的词法分析器变量。

char * lex_grow_linestr(STRLEN len)

lex_next_chunk
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

读取下一个要进行词法分析的文本块，将其附加到“PL_parser->linestr”。
当词法分析代码已经查看到当前块的末尾时，应该调用它
并想知道更多。 lexing 通常但不是必须的
此时消耗了整个当前块。

如果“PL_parser->bufptr”指向当前块的最后（即
当前块已被完全消耗），通常当前块将是
在读入新块的同时丢弃。如果 标志 包括
"LEX_KEEP_PREVIOUS"，当前块不会被丢弃。 如果当前
chunk 还没有被完全消耗掉，那么它不会被丢弃不管
标志。

如果向缓冲区添加了一些新文本，则返回 true，如果缓冲区有，则返回 false
到达输入文本的末尾。

bool lex_next_chunk（U32 标志）

lex_peek_unichar
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在当前被词法分析的文本中向前看一个 (Unicode) 字符。 退货
下一个字符的代码点（无符号整数值），如果 lexing 有，则为 -1
到达输入文本的末尾。 要消耗偷看的字符，请使用
“lex_read_unichar”。

如果下一个字符在（或延伸到）下一个输入文本块中，则
下一个块将被读入。通常当前块将在
同一时间，但如果 标志 包括 "LEX_KEEP_PREVIOUS" 那么当前块将
不被丢弃。

如果输入被解释为 UTF-8 并且 UTF-8 编码错误是
遇到，就会产生异常。

I32 lex_peek_unichar（U32 标志）

lex_read_space
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

以 Perl 风格读取当前正在被词法分析的文本中的可选空格。 这
空格可能包括普通的空白字符和 Perl 风格的注释。
如果遇到“#line”指令，将被处理。 “PL_parser->bufptr”被移动
过去的空格，所以它指向一个非空格字符（或结尾
输入文本）。

如果空格扩展到下一个输入文本块，则将读取下一个块
in. 通常会同时丢弃当前块，但如果 标志
包括“LEX_KEEP_PREVIOUS”，则当前块将不会被丢弃。

无效 lex_read_space（U32 标志）

lex_read_to
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

使用词法分析器缓冲区中的文本，从 "PL_parser->bufptr" 到 PTR。 这
推进“PL_parser->bufptr”以匹配 PTR，执行正确的簿记
每当传递换行符时。 这是使用 lexed 的正常方式
文本。

缓冲区八位字节的解释可以通过使用略
高级函数“lex_peek_unichar”和“lex_read_unichar”。

无效 lex_read_to(char *ptr)

lex_read_unichar
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

读取当前正在词法分析的文本中的下一个 (Unicode) 字符。 返回
读取的字符的代码点（无符号整数值），并移动
"PL_parser->bufptr" 超过字符，如果词法分析已达到
输入文本的结尾。 要无损检查下一个字符，请使用
“lex_peek_unichar”代替。

如果下一个字符在（或延伸到）下一个输入文本块中，则
下一个块将被读入。通常当前块将在
同一时间，但如果 标志 包括 "LEX_KEEP_PREVIOUS" 那么当前块将
不被丢弃。

如果输入被解释为 UTF-8 并且 UTF-8 编码错误是
遇到，就会产生异常。

I32 lex_read_unichar（U32 标志）

lex_start
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

创建并初始化一个新的词法分析器/解析器状态对象，提供一个上下文
从新的 Perl 代码源中对它进行 lex 和解析。 指向新状态的指针
对象被放置在“PL_parser”中。 在保存堆栈上创建一个条目，以便在
展开新的状态对象将被销毁并且之前的值
“PL_parser”将被恢复。 不需要做任何其他事情来清理解析
上下文。

要解析的代码来自 线 和 回复. 线，如果非空，提供一个
包含要解析的代码的字符串（SV 形式）。 制作了字符串的副本，
所以后续的修改 线 不影响解析。 回复，如果非空，
提供一个输入流，从中读取代码以进行解析。 如果两者都是
非空，代码在 线 首先出现并且必须包含完整的行
输入，和 回复 提供源的其余部分。

这个 标志 参数保留供将来使用。 目前它仅由 perl 使用
在内部，所以扩展应该总是通过零。

void lex_start（SV *line，PerlIO *rsfp，U32 标志）

lex_stuff_pv
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将字符插入词法分析器缓冲区（“PL_parser->linestr”），紧随其后
当前的词法分析点（“PL_parser->bufptr”），如果
必要的。 这意味着稍后运行的词法分析代码会将字符视为
如果它们出现在输入中。 不建议将其作为
正常解析，并且该工具的大多数使用都存在插入的风险
以非预期方式解释的字符。

要插入的字符串由八位字节表示 pv 并继续
到第一个 nul。 这些八位字节被解释为 UTF-8 或 Latin-1，
根据是否设置了“LEX_STUFF_UTF8”标志 标志. 那些角色
根据缓冲区当前的状态，为词法分析器缓冲区重新编码
解释（“lex_bufutf8”）。 如果不方便对字符串进行 nul 终止
被插入，“lex_stuff_pvn”函数更合适。

void lex_stuff_pv(const char *pv, U32 标志)

lex_stuff_pvn
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将字符插入词法分析器缓冲区（“PL_parser->linestr”），紧随其后
当前的词法分析点（“PL_parser->bufptr”），如果
必要的。 这意味着稍后运行的词法分析代码会将字符视为
如果它们出现在输入中。 不建议将其作为
正常解析，并且该工具的大多数使用都存在插入的风险
以非预期方式解释的字符。

要插入的字符串表示为 LEN 八位字节开始于 pv。 这些
八位字节被解释为 UTF-8 或 Latin-1，根据是否
“LEX_STUFF_UTF8”标志设置在 标志. 为词法分析器重新编码字符
缓冲区，根据当前解释缓冲区的方式
（“lex_bufutf8”）。 如果要插入的字符串可用作 Perl 标量，则
“lex_stuff_sv”函数更方便。

无效 lex_stuff_pvn(const char *pv, STRLEN len,
U32 标志）

lex_stuff_pvs
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

与“lex_stuff_pvn”类似，但采用文字字符串而不是字符串/长度对。

void lex_stuff_pvs(const char *pv, U32 标志)

lex_stuff_sv
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将字符插入词法分析器缓冲区（“PL_parser->linestr”），紧随其后
当前的词法分析点（“PL_parser->bufptr”），如果
必要的。 这意味着稍后运行的词法分析代码会将字符视为
如果它们出现在输入中。 不建议将其作为
正常解析，并且该工具的大多数使用都存在插入的风险
以非预期方式解释的字符。

要插入的字符串是字符串值 sv. 字符被重新编码
对于词法分析器缓冲区，根据当前解释缓冲区的方式
（“lex_bufutf8”）。 如果要插入的字符串还不是 Perl 标量，则
“lex_stuff_pvn”函数避免了构造标量的需要。

void lex_stuff_sv（SV *sv，U32 标志）

lex_unstuff
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

丢弃即将被词法分析的文本，从 "PL_parser->bufptr" 到 PTR。 文本
以下 PTR 将被移动，并且缓冲区缩短。 这隐藏了丢弃的
来自稍后运行的任何词法分析代码的文本，就好像该文本从未出现过一样。

这不是使用 lexed 文本的正常方式。 为此，请使用“lex_read_to”。

无效 lex_unstuff(char *ptr)

解析算术表达式
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析 Perl 算术表达式。 这可能包含优先级向下的运算符
到移位运算符。 必须遵循表达式（因此终止）
通过比较或较低优先级的运算符或通过一些可以
通常终止诸如分号之类的表达式。 如果 标志 包括
"PARSE_OPTIONAL" 那么表达式是可选的，否则是强制性的。 它
由调用者来确保动态解析器​​状态（“PL_parser”等）是
正确设置以反映要解析的代码的来源和词法
表达式的上下文。

返回表示表达式的操作树。 如果一个可选表达式是
如果不存在，则返回空指针，否则该指针将为非空。

如果解析或编译发生错误，大多数情况下有效的操作树是
反正回来了。 错误反映在解析器状态中，通常会导致
在涵盖所有编译的顶级解析的单个异常中
发生的错误。 但是，一些编译错误会抛出异常
立即。

OP * parse_arithexpr（U32 标志）

解析_barestmt
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析一个简单的 Perl 语句。 这可能是一个正常的命令
声明或具有编译时效果的声明。 它不包括任何
标签或其他附件。 由调用者来确保动态
解析器状态（“PL_parser”等）被正确设置以反映源
要解析的代码和语句的词法上下文。

返回表示该语句的操作树。 这可能是一个空指针，如果
该语句为空，例如，如果它实际上是一个子例程定义
（具有编译时副作用）。 如果不为null，则直接为ops
执行语句，适合传递给“newSTATEOP”。 它不会
通常包括一个“nextstate”或等效的操作（除了那些嵌入在
范围完全包含在声明中）。

如果在解析或编译过程中发生错误，大多数情况下有效的操作树（大多数
可能 null) 无论如何都会返回。 错误反映在解析器状态中，
通常会在解析的顶层导致一个异常，其中包括
发生的所有编译错误。 然而，一些编译错误会
立即抛出异常。

这个 标志 参数保留供将来使用，并且必须始终为零。

OP * parse_barestmt（U32 标志）

解析块
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析一个完整的 Perl 代码块。 这包括一个开口大括号、一个
语句序列和右大括号。 该块构成一个词汇
范围，因此“我的”变量和各种编译时效果可以包含在
它。 由调用者确保动态解析器​​状态（“PL_parser”
等）被正确设置以反映要解析的代码的来源和
语句的词汇上下文。

返回表示代码块的操作树。 这总是一个真正的操作，
绝不是空指针。 它通常是一个“lineseq”列表，包括“nextstate”
或等效的操作。 不包含构建任何类型的运行时范围的操作
因为它是一个块。

如果在解析或编译过程中发生错误，大多数情况下有效的操作树（大多数
可能 null) 无论如何都会返回。 错误反映在解析器状态中，
通常会在解析的顶层导致一个异常，其中包括
发生的所有编译错误。 然而，一些编译错误会
立即抛出异常。

这个 标志 参数保留供将来使用，并且必须始终为零。

OP * parse_block（U32 标志）

parse_fullexpr
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析一个完整的 Perl 表达式。 这允许完整的表达式语法，
包括最低优先级的运算符，例如“或”。 表达式必须是
后跟（并因此终止）表达式通常是的标记
终止于：文件结尾、右括号标点符号、分号或以下之一
表示后缀表达式语句修饰符的关键字。 如果 标志
包括 "PARSE_OPTIONAL" 那么表达式是可选的，否则是
强制的。 由调用者确保动态解析器​​状态
("PL_parser" et al) 被正确设置以反映代码的来源
解析和表达式的词法上下文。

返回表示表达式的操作树。 如果一个可选表达式是
如果不存在，则返回空指针，否则该指针将为非空。

如果解析或编译发生错误，大多数情况下有效的操作树是
反正回来了。 错误反映在解析器状态中，通常会导致
在涵盖所有编译的顶级解析的单个异常中
发生的错误。 但是，一些编译错误会抛出异常
立即。

OP * parse_fullexpr（U32 标志）

解析全文
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析一个完整的 Perl 语句。 这可能是一个正常的命令式陈述
或具有编译时效果的声明，并且可能包含可选标签。
由调用者确保动态解析器​​状态（“PL_parser”等）
正确设置以反映要解析的代码的来源和词法
声明的上下文。

返回表示该语句的操作树。 这可能是一个空指针，如果
该语句为空，例如，如果它实际上是一个子例程定义
（具有编译时副作用）。 如果不为空，它将是一个结果
“newSTATEOP”调用，通常包括“nextstate”或等效操作。

如果在解析或编译过程中发生错误，大多数情况下有效的操作树（大多数
可能 null) 无论如何都会返回。 错误反映在解析器状态中，
通常会在解析的顶层导致一个异常，其中包括
发生的所有编译错误。 然而，一些编译错误会
立即抛出异常。

这个 标志 参数保留供将来使用，并且必须始终为零。

OP * parse_fullstmt（U32 标志）

解析标签
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析可以作为 Perl 前缀的类型的单个标签，可能是可选的
陈述。 由调用者确保动态解析器​​状态
("PL_parser" et al) 被正确设置以反映代码的来源
解析。 如果 标志 包括 "PARSE_OPTIONAL" 那么标签是可选的，否则
这是强制性的。

标签的名称以新标量的形式返回。 如果一个可选的
标签不存在，返回一个空指针。

如果在解析中发生错误，只有在标签是强制性的情况下才会发生，a
无论如何都会返回有效标签。 错误反映在解析器状态中，
通常会在解析的顶层导致一个异常，其中包括
发生的所有编译错误。

SV * parse_label(U32 标志)

解析列表表达式
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析 Perl 列表表达式。 这可能包含优先级低至
逗号运算符。 必须遵循（并因此终止）表达式
通过诸如“或”之类的低优先级逻辑运算符或将
通常终止诸如分号之类的表达式。 如果 标志 包括
"PARSE_OPTIONAL" 那么表达式是可选的，否则是强制性的。 它
由调用者来确保动态解析器​​状态（“PL_parser”等）是
正确设置以反映要解析的代码的来源和词法
表达式的上下文。

返回表示表达式的操作树。 如果一个可选表达式是
如果不存在，则返回空指针，否则该指针将为非空。

如果解析或编译发生错误，大多数情况下有效的操作树是
反正回来了。 错误反映在解析器状态中，通常会导致
在涵盖所有编译的顶级解析的单个异常中
发生的错误。 但是，一些编译错误会抛出异常
立即。

OP * parse_listexpr（U32 标志）

解析_stmtseq
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析零个或多个 Perl 语句的序列。 这些可能是正常的命令
语句，包括可选标签或具有编译时的声明
效果，或其任何混合物。 语句序列在右大括号时结束
或在新语句可能有效的地方遇到文件结尾
开始了。 由调用者确保动态解析器​​状态
("PL_parser" et al) 被正确设置以反映代码的来源
解析和语句的词汇上下文。

返回表示语句序列的操作树。 这可能是一个空
如果语句全部为空，则指针，例如，如果没有语句
或者如果只有子例程定义（具有编译时方面
影响）。 如果不为空，它将是一个“lineseq”列表，通常包括
“nextstate”或等效操作。

如果解析或编译发生错误，大多数情况下有效的操作树是
反正回来了。 错误反映在解析器状态中，通常会导致
在涵盖所有编译的顶级解析的单个异常中
发生的错误。 但是，一些编译错误会抛出异常
立即。

这个 标志 参数保留供将来使用，并且必须始终为零。

OP * parse_stmtseq（U32 标志）

解析术语表达式
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

解析 Perl 术语表达式。 这可能包含优先级低至
赋值运算符。 必须遵循表达式（因此终止）
通过逗号或优先级较低的运算符或通过通常会
终止诸如分号之类的表达式。 如果 标志 包括“PARSE_OPTIONAL”
那么表达式是可选的，否则是强制性的。 这取决于
调用者确保动态解析器​​状态（“PL_parser”等）正确
设置以反映要解析的代码的源和
表达。

返回表示表达式的操作树。 如果一个可选表达式是
如果不存在，则返回空指针，否则该指针将为非空。

如果解析或编译发生错误，大多数情况下有效的操作树是
反正回来了。 错误反映在解析器状态中，通常会导致
在涵盖所有编译的顶级解析的单个异常中
发生的错误。 但是，一些编译错误会抛出异常
立即。

OP * parse_termexpr（U32 标志）

PL_解析器
指向封装当前解析操作状态的结构的指针
进行中。 可以在本地更改指针以执行嵌套解析，而无需
干扰外部解析的状态。 “PL_parser”的个别成员
有自己的文档。

PL_parser->bufend
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

指向当前正在被词法分析的文本块末尾的直接指针，
词法分析器缓冲区。 这等于“SvPVX(PL_parser->linestr) +
SvCUR(PL_parser->linestr)”。一个“NUL”字符（零八位字节）总是位于
缓冲区的末尾，不计入缓冲区内容的一部分。

PL_parser->bufptr
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

指向词法分析器缓冲区中词法分析的当前位置。 人物
围绕这一点可以自由地检查，在界定的范围内
"SvPVX("PL_parser->linestr")" 和 "PL_parser->bufend"。 缓冲区的八位字节
可能旨在解释为 UTF-8 或 Latin-1，如
“lex_bufutf8”。

词法分析代码（无论是否在 Perl 核心中）将此指针移过
它消耗的字符。 预计还会进行一些簿记
每当使用换行符时。 这个动作可以更方便
由函数“lex_read_to”执行，该函数适当地处理换行符。

缓冲区八位字节的解释可以通过使用略
高级函数“lex_peek_unichar”和“lex_read_unichar”。

PL_parser->linestart
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

指向词法分析器缓冲区内当前行的开头。 这很有用
用于指示在哪一列发生了错误，仅此而已。 这必须是
由任何使用换行符的词法代码更新； 函数“lex_read_to”
处理这个细节。

PL_parser->linestr
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

包含当前正在考虑文本的块的缓冲区标量
目前正在使用 lexed。 这始终是一个纯字符串标量（“SvPOK”是
真的）。 它不打算通过正常的标量方式用作标量； 反而
通过下面描述的指针变量直接引用缓冲区。

词法分析器在“PL_parser->linestr”中维护各种“char*”指针
缓冲。 如果“PL_parser->linestr”被重新分配，所有这些指针必须
被更新。 不要尝试手动执行此操作，而是使用“lex_grow_linestr”
如果您需要重新分配缓冲区。

缓冲区中文本块的内容通常正好是一整行
输入，最多并包括换行符终止符，但在某些情况下
不然。 缓冲区的八位字节可能被解释为
UTF-8 或 Latin-1。 函数“lex_bufutf8”告诉你哪个。 不使用
此标量上的“SvUTF8”标志，可能不同意它。

对于缓冲区的直接检查，变量“PL_parser->bufend”指向
缓冲区的末端。 当前的词法位置由
“PL_parser->bufptr”。 直接使用这些指针通常比
通过正常标量方法检查标量。

与语言环境相关的 功能 和 宏

DECLARATION_FOR_LC_NUMERIC_MANIPULATION
此宏应用作语句。 它声明了一个私有变量（其
名称以下划线开头），这是其他宏需要的
部分。 未能正确包含此内容会导致语法错误。 为了
与 C89 C 编译器的兼容性它应该放在一个块之前
可执行语句。

无效 DECLARATION_FOR_LC_NUMERIC_MANIPULATION

RESTORE_LC_NUMERIC
这与其中一个宏一起使用
“STORE_LC_NUMERIC_SET_TO_NEEDED”和“STORE_LC_NUMERIC_FORCE_TO_UNDERLYING”

正确恢复“LC_NUMERIC”状态。

必须调用“DECLARATION_FOR_LC_NUMERIC_MANIPULATION”来声明
在编译时，这个宏和两个“STORE”使用的私有变量。
这个宏应该作为一个单独的语句调用，而不是一个表达式，而是一个
空参数列表，如下所示：

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

无效 RESTORE_LC_NUMERIC()

STORE_LC_NUMERIC_FORCE_TO_UNDERLYING
这由“LC_NUMERIC”区域设置感知的 XS 代码使用，以强制区域设置
对于“LC_NUMERIC”类别，perl 认为是当前的基础语言环境。
（perl 解释器可能对底层语言环境实际上是错误的
如果某些 C 或 XS 代码调用了 C 库函数 设置区域(3) 其背后
背部; 在调用此宏之前调用“sync_locale”将更新 perl 的记录。）

必须调用“DECLARATION_FOR_LC_NUMERIC_MANIPULATION”来声明
在编译时此宏使用的私有变量。 这个宏应该是
作为单个语句调用，而不是表达式，但带有一个空参数列表，
喜欢这个：

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

私有变量用于保存当前的语言环境状态，以便
对“RESTORE_LC_NUMERIC”的必要匹配调用可以恢复它。

无效 STORE_LC_NUMERIC_FORCE_TO_UNDERLYING()

STORE_LC_NUMERIC_SET_TO_NEEDED
这用于帮助包装“LC_NUMERIC”区域设置感知的 XS 或 C 代码。
此语言环境类别通常由 Perl 保持设置为 C 语言环境以用于向后
兼容性，并且因为大多数读取浮点值的 XS 代码都可以应付
只有十进制基数字符是一个点。

此宏确保正确设置当前的“LC_NUMERIC”状态，请注意
如果从 Perl 程序调用 XS 或 C 代码是从
“使用语言环境”的范围； 或者如果呼叫是来自外部，则忽略区域设置
这样的范围。

这个宏是包装 C 或 XS 代码的开始； 换行结束由
操作后调用“RESTORE_LC_NUMERIC”宏。 否则状态
可以更改将对其他 XS 代码产生不利影响。

必须调用“DECLARATION_FOR_LC_NUMERIC_MANIPULATION”来声明
在编译时此宏使用的私有变量。 这个宏应该是
作为单个语句调用，而不是表达式，但带有一个空参数列表，
喜欢这个：

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

无效 STORE_LC_NUMERIC_SET_TO_NEEDED()

同步语言环境
XS 代码应避免更改程序的语言环境。 尽管如此，某些
从 XS 调用的非 Perl 库，例如 "Gtk" 这样做。 发生这种情况时，Perl
需要告知语言环境已更改。 使用此功能执行此操作，之前
回到 Perl。

无效同步语言环境（）

神奇 功能

毫克_清除
清除 SV 所代表的神奇事物。 参见“sv_magic”。

int mg_clear(SV* sv)

mg_copy 将魔法从一个 SV 复制到另一个。 参见“sv_magic”。

int mg_copy(SV *sv, SV *nsv, const char *key,
I32 克伦）

mg_find 查找与 SV 匹配的类型的魔术指针。 参见“sv_magic”。

MAGIC* mg_find(const SV* sv, int 类型)

mg_findext
使用“SV”的给定“vtbl”查找“type”的魔术指针。 看
“sv_magicext”。

MAGIC* mg_findext(const SV* sv, int 类型,
常量 MGVTBL *vtbl)

mg_free 释放 SV 使用的任何魔法存储。 参见“sv_magic”。

int mg_free(SV* sv)

mg_free_type
移除任何类型的魔法 形成一种 来自 SV sv. 参见“sv_magic”。

void mg_free_type(SV *sv, int how)

mg_get 在从 SV 检索值之前执行魔术。 SV 的类型必须 >=
SVt_PVMG。 参见“sv_magic”。

int mg_get(SV* sv)

毫克长度
已弃用！ 计划从 Perl 的未来版本中删除此功能。
不要将它用于新代码； 从现有代码中删除它。

以字节为单位报告 SV 的长度，如果可用，则调用长度魔法，但确实如此
未在 sv 上设置 UTF8 标志。 如果没有，它将退回到“获得”魔法
'length' 魔法，但没有说明它是否称为 'get' 魔法。 它
假设 sv 是 PVMG 或更高。 利用 sv_len() 代替。

U32 mg_length(SV* sv)

魔法魔法
开启 SV 的魔法状态。 参见“sv_magic”。

无效mg_magical（SV * sv）

mg_set 在将值分配给 SV 后施展魔法。 参见“sv_magic”。

int mg_set(SV* sv)

魔力
如果 SV 具有“get”魔法，则在 SV 上调用“mg_get”。 例如，这将调用
绑定变量上的“FETCH”。 这个宏不止一次地评估它的参数。

无效 SvGETMAGIC(SV* sv)

SvLOCK 安排在 sv 上获得互斥锁，如果合适的模块有
已加载。

无效 SvLOCK(SV* sv)

魔力
如果 SV 具有“设置”魔法，则在 SV 上调用“mg_set”。 这是必要的
修改标量，以防它是像 $| 这样的神奇变量或绑定变量
（它称为“存储”）。 这个宏不止一次地评估它的参数。

无效 SvSETMAGIC(SV* sv)

设置魔术SV
像“SvSetSV”，但之后需要任何设置魔法。

无效 SvSetMagicSV(SV* dsv, SV* ssv)

SvSetMagicSV_nosteal
像“SvSetSV_nosteal”，但之后需要任何设置魔法。

无效 SvSetMagicSV_nosteal(SV* dsv, SV* ssv)

SvSetSV 如果 dsv 与 ssv 不同，则调用“sv_setsv”。 可以评估论点超过
一次。 不处理目标 SV 上的“设置”魔法。

无效 SvSetSV(SV* dsv, SV* ssv)

SvSetSV_nosteal
如果 dsv 与 ssv 不同，则调用“sv_setsv”的非破坏性版本。 可能
不止一次地评估论点。

无效 SvSetSV_nosteal(SV* dsv, SV* ssv)

SvSHARE 如果已加载合适的模块，则安排 sv 在线程之间共享。

无效 SvSHARE(SV* sv)

解锁
如果已加载合适的模块，则释放 sv 上的互斥锁。

无效 SvUNLOCK(SV* sv)

内存 管理团队

将 XSUB-writer 的接口复制到 C“memcpy”函数。 “src”是来源，
“dest”是目的地，“nitems”是项目数，“type”是
类型。 重叠副本可能会失败。 另见“移动”。

void Copy(void* src, void* dest, int nitems, 类型)

CopyD 与“复制”类似，但返回 dest。 有助于鼓励编译器尾调用
优化。

void * CopyD(void* src, void* dest, int nitems, 类型)

将 XSUB 编写器的接口移动到 C 的“memmove”函数。 “src”是来源，
“dest”是目的地，“nitems”是项目数，“type”是
类型。 可以做重叠动作。 另见“复制”。

void Move(void* src, void* dest, int nitems, 类型)

MoveD 与“Move”类似，但返回 dest。 有助于鼓励编译器尾调用
优化。

void * MoveD(void* src, void* dest, int nitems, 类型)

Newx XSUB 编写器对 C“malloc”函数的接口。

由此获得的内存应该 仅 用“Safefree”释放。

5.9.3年， 纽克斯() 和朋友替换旧的 新（） API，并丢弃第一个
参数， x，一种调试辅助工具，允许调用者识别自己。 这种援助
已被新的构建选项 PERL_MEM_LOG 取代（请参阅“PERL_MEM_LOG”
提示）。 旧的 API 仍然可以在 XS 模块中使用，支持
较旧的 perls。

void Newx(void* ptr, int nitems, 类型)

Newxc XSUB 编写器对 C“malloc”函数的接口，带有强制转换。 也可以看看
“纽克斯”。

由此获得的内存应该 仅 用“Safefree”释放。

void Newxc(void* ptr, int nitems, 类型, 强制转换)

Newxz XSUB 编写器对 C“malloc”函数的接口。 分配的内存是
用“memzero”归零。 另见“Newx”。

由此获得的内存应该 仅 用“Safefree”释放。

void Newxz(void* ptr, int nitems, 类型)

毒 毒与(0xEF) 用于捕获对已释放内存的访问。

void Poison(void* dest, int nitems, 类型)

无毒
毒与(0xEF) 用于捕获对已释放内存的访问。

void PoisonFree(void* dest, int nitems, 类型)

毒新
毒与(0xAB) 用于捕获对已分配但未初始化的内存的访问。

void PoisonNew(void* dest, int nitems, 类型)

毒与
用字节模式（一遍又一遍地重复的字节）填充内存
希望能捕获访问未初始化内存的尝试。

void PoisonWith(void* dest, int nitems, 类型,
U8 字节）

更新 XSUB 编写器与 C“realloc”函数的接口。

由此获得的内存应该 仅 用“Safefree”释放。

void Renew(void* ptr, int nitems, 类型)

Renewc XSUB 编写器对 C“realloc”函数的接口，带有强制转换。

由此获得的内存应该 仅 用“Safefree”释放。

void Renewc(void* ptr, int nitems, 类型, 强制转换)

无安全
XSUB 编写器与 C“free”函数的接口。

这应该 仅 用于使用“Newx”和朋友获得的内存。

无效 Safefree(无效* ptr)

savepv Perl 版本的“strdup()”。 返回一个指向新分配的字符串的指针
是“pv”的副本。 字符串的大小由“strlen()”决定，它
意味着它可能不包含嵌入的“NUL”字符，并且必须有一个尾随的“NUL”。
为新字符串分配的内存可以使用“Safefree()”释放
功能。

在某些平台上，例如 Windows，线程拥有的所有分配的内存都是
当该线程结束时释放。 因此，如果您不希望这种情况发生，您需要
使用共享内存功能，例如“savesharedpv”。

char* savepv(常量 char* pv)

savepvn Perl 版本的“strndup()”如果存在的话。 返回指向 a 的指针
新分配的字符串，它是“pv”中第一个“len”字节的副本，
加上一个尾随的“NUL”字节。 可以释放为新字符串分配的内存
使用“Safefree()”函数。

在某些平台上，例如 Windows，线程拥有的所有分配的内存都是
当该线程结束时释放。 因此，如果您不希望这种情况发生，您需要
使用共享内存功能，例如“savesharedpvn”。

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

savepvs 与“savepvn”类似，但采用文字“NUL”结尾的字符串而不是
字符串/长度对。

char* savepvs（const char* s）

保存共享PV
“savepv()”的一个版本，它在内存中分配重复的字符串，即
线程之间共享。

char* savesharedpv(const char* pv)

保存共享pvn
“savepvn()”的一个版本，它在内存中分配重复的字符串，即
线程之间共享。 （具体的区别是 NULL 指针不是
可接受）

char* savesharedpvn(const char *const pv,
const STRLEN 长度）

保存共享PV
“savepvs()”的一个版本，它在内存中分配重复的字符串，即
线程之间共享。

char* savesharedpvs(const char* s)

保存共享svpv
“savesharedpv()”的一个版本，它在内存中分配重复的字符串
在线程之间共享。

字符* savesharedsvpv(SV *sv)

保存vpv
“savepv()”/“savepvn()” 的一个版本，它从
使用“SvPV()”传入 SV

在某些平台上，例如 Windows，线程拥有的所有分配的内存都是
当该线程结束时释放。 因此，如果您不希望这种情况发生，您需要
使用共享内存功能，例如“savesharedsvpv”。

字符* savesvpv(SV* sv)

结构复制
这是一个独立于体系结构的宏，用于将一个结构复制到另一个结构。

void StructCopy（类型 *src，类型 *dest，类型）

Zero XSUB 编写器与 C“memzero”函数的接口。 “dest”是
目的地，“nitems”是项目数，“type”是类型。

void Zero(void* dest, int nitems, 类型)

ZeroD 与“零”类似，但返回 dest。 有助于鼓励编译器尾调用
优化。

void * ZeroD(void* dest, int nitems, 类型)

其他 功能

dump_c_backtrace
将 C 回溯转储到给定的 fp。

如果可以检索回溯，则返回 true，否则返回 false。

bool dump_c_backtrace(PerlIO* fp, int max_深度,
int跳过）

fbm_编译
分析字符串以便使用它进行快速搜索 fbm_instr() - 这
Boyer-Moore 算法。

void fbm_compile(SV* sv, U32 标志)

fbm_指令
返回由“big”和“bigend”分隔的字符串中 SV 的位置。 它
如果找不到字符串，则返回“NULL”。 “sv”不必是
fbm_compiled，但搜索不会那么快。

char* fbm_instr(unsigned char* 大,
无符号字符* bigend，SV* Littlestr，
U32 标志）

foldEQ 如果字符串 s1 和 s2 的前 len 字节大小写相同，则返回 true -
麻木不仁； 否则为假。 大小写 ASCII 范围字节匹配
他们自己和他们相反的案例同行。 非大小写和非 ASCII 范围
字节只匹配它们自己。

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

FoldEQ_区域设置
如果字符串 s1 和 s2 的前导 len 字节大小写相同，则返回 true -
在当前语言环境中不敏感； 否则为假。

I32 FoldEQ_locale(const char* a, const char* b,
I32 镜头）

form 采用 sprintf 风格的格式模式和常规（非 SV）参数和
返回格式化的字符串。

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

可以在任何需要字符串 (char *) 的地方使用：

char * s = Perl_form("%d.%d",major,minor);

使用单个私有缓冲区，因此如果要格式化多个字符串，则必须
显式复制较早的字符串（并在完成后释放副本）。

char* 形式（const char* pat, ...）

获取cwd_sv
用当前工作目录填充 sv

int getcwd_sv(SV* sv)

获取c_backtrace_dump
返回一个 SV 转储 |depth| 调用堆栈的帧，跳过 |skip|
最里面的。 20 的深度通常就足够了。

附加的输出如下所示：

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

这些字段是制表符分隔的。 第一列是深度（零是
最里面的非跳帧）。 在 hex:offset 中，hex 是程序所在的位置
计数器在 S_parse_body 中，并且 :offset （可能丢失）告诉了多少
在 S_parse_body 里面是程序计数器。

util.c:1716 是源代码文件和行号。

这个 /usr/bin/perl 很明显（希望如此）。

未知数是“-”。 不幸的是，未知数很容易发生：如果平台
不支持检索信息； 如果二进制文件缺少调试
信息; 如果优化器通过内联等方式转换了代码。

SV* get_c_backtrace_dump（int max_depth，int skip）

ibcmp 这是 (! 折叠均衡器（）)

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

ibcmp_区域设置
这是 (! FoldEQ_locale())

I32 ibcmp_locale(const char* a, const char* b,
I32 镜头）

is_safe_syscall
测试给定的“pv”不包含任何内部“NUL”字符。 如果它
确实，将“errno”设置为 ENOENT，可选择警告并返回 FALSE。

如果名称是安全的，则返回 TRUE。

使用的 IS_SAFE_SYSCALL() 宏。

bool is_safe_syscall(const char *pv, STRLEN len,
const char *什么，
常量字符 *op_name)

memEQ 测试两个缓冲区（可能包含嵌入的“NUL”字符，看看它们是否是
平等的。 “len”参数表示要比较的字节数。 退货
如果相等则为零，如果不相等则为非零。

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

memNE 测试两个缓冲区（可能包含嵌入的“NUL”字符，看看它们是否是
不相等。 “len”参数表示要比较的字节数。 退货
如果不相等则为零，如果相等则为非零。

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

mess 采用 sprintf 风格的格式模式和参数列表。 这些用于生成
字符串消息。 如果消息不以换行符结尾，那么它将是
扩展了代码中当前位置的一些指示，如所述
对于“mess_sv”。

通常，生成的消息会在一个新的凡人 SV 中返回。 在全球范围内
销毁单个 SV 可以在此功能的使用之间共享。

SV * 混乱(const char *pat, ...)

mess_sv 为用户扩展一条消息，包括当前的指示
代码中的位置，如果消息似乎尚未完成。

“basemsg”是初始消息或对象。 如果它是参考，它将被使用
原样并将成为此功能的结果。 否则它被用作字符串，
如果它已经以换行符结束，则认为它是完整的，结果
这个函数的将是相同的字符串。 如果消息不以
换行符，然后将附加诸如“at foo.pl line 37”之类的段，并且可能
指示当前执行状态的其他子句。 结果消息
将以点和换行符结尾。

通常，生成的消息会在一个新的凡人 SV 中返回。 在全球范围内
销毁单个 SV 可以在此功能的使用之间共享。 如果“消费”
为真，则该函数被允许（但不是必须）修改并返回
“basemsg”而不是分配一个新的 SV。

SV * mess_sv(SV *basemsg, bool 消耗)

my_snprintf
C 库“snprintf”功能，如果可用且符合标准（使用
“vsnprintf”，实际上）。 但是，如果“vsnprintf”不可用，将
不幸的是使用了不安全的“vsprintf”，它可能会溢出缓冲区（有一个
超限检查，但这可能为时已晚）。 考虑改用“sv_vcatpvf”，或者
得到“vsnprintf”。

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

我的_sprintf
C 库“sprintf”，必要时包装，以确保它将返回
写入缓冲区的字符串的长度。 只有极少数的 pre-ANSI 系统需要
包装函数 - 通常这是对“sprintf”的直接调用。

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

my_strlcat
C 库“strlcat”（如果可用）或它的 Perl 实现。 这
对 C "NUL" 终止的字符串进行操作。

"my_strlcat()" 将字符串 "src" 附加到 "dst" 的末尾。 它最多会附加
“大小 - strlen(dst) - 1”字符。 然后它将“NUL”终止，除非“size”
为 0 或原始“dst”字符串比“size”长（实际上这应该
不会发生，因为这意味着“大小”不正确或“dst”不是
正确的以“NUL”结尾的字符串）。

请注意，“size”是目标缓冲区的完整大小，结果是
如果有空间，保证是“NUL”终止的。 注意“NUL”的空间
应包含在“大小”中。

size_t my_strlcat(char *dst, const char *src,
size_t 尺寸）

my_strlcpy
C 库“strlcpy”（如果可用）或它的 Perl 实现。 这
对 C "NUL" 终止的字符串进行操作。

“my_strlcpy()”从字符串“src”复制最多“size - 1”个字符到“dst”，
“NUL” - 如果“size”不为 0，则终止结果。

size_t my_strlcpy(char *dst, const char *src,
size_t 尺寸）

my_vsnprintf
C 库“vsnprintf”（如果可用且符合标准）。 然而，如果
“vsnprintf”不可用，不幸的是会使用不安全的“vsprintf”
这可能会溢出缓冲区（有一个溢出检查，但这也可能是
晚了）。 考虑改用“sv_vcatpvf”，或获取“vsnprintf”。

int my_vsnprintf(char *buffer, const Size_t len,
const char *format, va_​​list ap)

PERL_SYS_INIT
提供运行所需的 C 运行时环境的系统特定调整
Perl 解释器。 这应该只调用一次，在创建任何 Perl 之前
口译员。

无效 PERL_SYS_INIT(int *argc, char*** argv)

PERL_SYS_INIT3
提供运行所需的 C 运行时环境的系统特定调整
Perl 解释器。 这应该只调用一次，在创建任何 Perl 之前
口译员。

void PERL_SYS_INIT3(int *argc, char*** argv,
字符***环境）

PERL_SYS_TERM
在运行 Perl 后提供系统特定的 C 运行时环境清理
口译员。 这应该只调用一次，在释放任何剩余的 Perl 之后
口译员。

无效 PERL_SYS_TERM()

需要quadmath_format_
Quadmath_format_needed() 如果格式字符串似乎包含 at，则返回 true
至少一个非 Q 前缀的 %[efgaEFGA] 格式说明符，否则返回 false。

格式说明符检测不是完整的 printf-syntax 检测，而是
应该抓住最常见的情况。

如果返回 true，则这些参数 应该 理论上可以处理
Quadmath_snprintf(), 但如果有多个这样的格式说明符（请参阅
“quadmath_format_single”），如果还有其他东西（甚至
只是一个字节），他们 不能 被处理，因为 Quadmath_snprintf() 很
严格，只接受一种格式规范，没有别的。 在这种情况下，代码
应该可能会失败。

bool quadmath_format_needed(const char* 格式)

Quadmath_format_single
Quadmath_snprintf() 对其格式字符串非常严格，会失败，
如果格式无效，则返回 -1。 它只接受一种格式规范。

Quadmath_format_single() 检查预期的单一规范是否正常：开始
带“%”，只有一个“%”，以“[efgaEFGA]”结尾，前面有“Q”。 这
不是完整的“printf 语法检查”，只是基础知识。

如果格式有效，则返回格式，否则返回 NULL。

Quadmath_format_single() 可以并且实际上会修补丢失的“Q”，如果
必要的。 在这种情况下，它将返回格式的修改副本， 这 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。
呼叫者 将 需要 至 免费的。

另见“quadmath_format_needed”。

const char* quadmath_format_single(const char* 格式)

READ_XDIGIT
返回 ASCII 范围的十六进制数字的值并推进字符串指针。
只有当 isXDIGIT(*str) 为真时，行为才能得到很好的定义。

U8 READ_XDIGIT(字符 str*)

strEQ 测试两个字符串是否相等。 返回真或假。

布尔 strEQ（字符 * s1，字符 * s2）

strGE 测试两个字符串，看第一个字符串“s1”是否大于或等于
第二，“s2”。 返回真或假。

布尔 strGE(char* s1, char* s2)

strGT 测试两个字符串，看第一个“s1”是否大于第二个“s2”。
返回真或假。

布尔 strGT(char* s1, char* s2)

strLE 测试两个字符串，看第一个“s1”是否小于或等于第二个，
“s2”。 返回真或假。

布尔 strLE(char* s1, char* s2)

strLT 测试两个字符串，看第一个字符串“s1”是否小于第二个字符串“s2”。
返回真或假。

布尔 strLT(char* s1, char* s2)

strNE 测试两个字符串，看看它们是否不同。 返回真或假。

bool strNE(字符* s1, 字符* s2)

strnEQ 测试两个字符串是否相等。 “len”参数表示
要比较的字节数。 返回真或假。 （“strncmp”的包装）。

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

strnNE 测试两个字符串，看看它们是否不同。 “len”参数表示
要比较的字节数。 返回真或假。 （“strncmp”的包装）。

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

sv_可销毁
报告对象可以在没有共享时被销毁的虚拟例程
模块存在。 它忽略其单个 SV 参数，并返回“真”。 存在于
避免测试 NULL 函数指针，因为它可能会在
某种程度的严格性。

布尔 sv_destroyable(SV *sv)

sv_无共享
当不存在共享模块时“共享”一个 SV 的虚拟例程。 要么
“锁定”它。 或“解锁”它。 换句话说，忽略其单个 SV 参数。
存在是为了避免对 NULL 函数指针进行测试，并且因为它可能潜在地
在某种严格程度下发出警告。

无效 sv_nosharing(SV *sv)

vmess "pat" 和 "args" 是 sprintf 风格的格式模式和封装的参数
列表。 这些用于生成字符串消息。 如果消息没有结束
使用换行符，然后它将扩展为当前的一些指示
代码中的位置，如“mess_sv”所述。

通常，生成的消息会在一个新的凡人 SV 中返回。 在全球范围内
销毁单个 SV 可以在此功能的使用之间共享。

SV * vmess(const char *pat, va_​​list *args)

维修 功能

这些函数与perl类的方法解析顺序有关

mro_get_线性_isa
返回给定存储的 mro 线性化。 默认情况下，这将是
无论“mro_get_linear_isa_dfs”返回什么，除非其他一些 MRO 对
藏匿处。 返回值是一个只读的 AV*。

如果您打算存储，则您应对返回值的“SvREFCNT_inc()”负责
它可以半永久性地在任何地方（否则它可能会从你下面删除）
下次缓存失效时）。

AV* mro_get_linear_isa(HV* 存储)

mro_method_changed_in
使给定存储的任何子类上的方法缓存无效，以便它们
可能会注意到这一点的变化。

理想情况下，perl 源代码中“PL_sub_generation++”的所有实例都在 姆罗.c
应由对此的调用替换。

Perl 自动处理可能重新定义方法的大多数常见方式。
但是，有几种方法可以在没有
缓存代码通知，在这种情况下，您需要在之后调用此方法：

1) 直接从 XS 代码操作隐藏 HV 条目。

2) 将只读标量常量的引用按顺序分配到存储条目中
创建一个常量子程序（就像 constant.pm 一样）。

同样的方法可以从纯 perl 中通过，
“mro::method_changed_in（类名）”。

无效 mro_method_changed_in（HV* 存储）

mro_注册
注册一个自定义 mro 插件。 有关详细信息，请参阅 perlmroapi。

无效 mro_register(const struct mro_alg *mro)

多路通话 功能

多路通话
为多重调用声明局部变量。 请参阅 perlcall 中的“轻量级回调”。

多路通话；

多路电话
进行轻量级回调。 请参阅 perlcall 中的“轻量级回调”。

多路电话；

POP_MULTICALL
轻量级回调的右括号。 参见“轻量级回调”
调用。

POP_MULTICALL；

PUSH_MULTICALL
轻量级回调的左括号。 参见“轻量级回调”
调用。

PUSH_MULTICALL；

数字 功能

格罗克_bin
将表示二进制数的字符串转换为数字形式。

入境时 开始 和 * len 给出要扫描的字符串， *标志 给出转换标志，
和 导致 应该是 NULL 或指向 NV 的指针。 扫描在结束时停止
字符串，或第一个无效字符。 除非设置了“PERL_SCAN_SILENT_ILLDIGIT”
in *标志，遇到无效字符也会触发警告。 在
回报 * len 设置为扫描字符串的长度，并且 *标志 给出输出
标志。

如果值 <= "UV_MAX" 它作为 UV 返回，输出标志是明确的，
并且没有写入任何内容 * 结果. 如果值 > UV_MAX "grok_bin" 返回
UV_MAX，在输出标志中设置“PERL_SCAN_GREATER_THAN_UV_MAX”，并写入
价值 * 结果 （或者如果该值被丢弃 导致 一片空白）。

二进制数可以选择以“0b”或“b”作为前缀，除非
“PERL_SCAN_DISALLOW_PREFIX”设置在 *标志 入境时。 如果
“PERL_SCAN_ALLOW_UNDERSCORES”设置在 *标志 那么二进制数可以使用'_'
字符来分隔数字。

UV grok_bin(const char* start, STRLEN* len_p,
I32* 标志，NV *结果）

格罗克十六进制
将表示十六进制数的字符串转换为数字形式。

入境时 开始 和 *len_p 给出要扫描的字符串， *标志 给出转换标志，
和 导致 应该是 NULL 或指向 NV 的指针。 扫描在结束时停止
字符串，或第一个无效字符。 除非设置了“PERL_SCAN_SILENT_ILLDIGIT”
in *标志，遇到无效字符也会触发警告。 在
回报 * len 设置为扫描字符串的长度，并且 *标志 给出输出
标志。

如果值 <= UV_MAX 它作为 UV 返回，输出标志是清晰的，并且
没有写入任何内容 * 结果. 如果值 > UV_MAX "grok_hex" 返回
UV_MAX，在输出标志中设置“PERL_SCAN_GREATER_THAN_UV_MAX”，并写入
价值 * 结果 （或者如果该值被丢弃 导致 一片空白）。

十六进制数可以选择以“0x”或“x”作为前缀，除非
“PERL_SCAN_DISALLOW_PREFIX”设置在 *标志 入境时。 如果
“PERL_SCAN_ALLOW_UNDERSCORES”设置在 *标志 那么十六进制数可以使用'_'
字符来分隔数字。

UV grok_hex(const char* start, STRLEN* len_p,
I32* 标志，NV *结果）

格罗克_infnan
帮手 grok_number(), 接受各种拼写“infinity”或“not a
number”，并返回以下标志组合之一：

IS_NUMBER_INFINITE
IS_NUMBER_NAN
IS_NUMBER_INFINITE | IS_NUMBER_NEG
IS_NUMBER_NAN | IS_NUMBER_NEG
0

可能 |-ed 与 IS_NUMBER_TRAILING。

如果识别出无穷大或非数字，*sp 将指向一个字节
超过已识别字符串的结尾。 如果识别失败，则为零
返回，并且 *sp 不会移动。

int grok_infnan(const char** sp, const char *发送)

格罗克号
相同 grok_number_flags() 标志设置为零。

int grok_number(const char *pv, STRLEN len,
紫外线*值p)

grok_number_flags
认识（或不认识）一个数字。 返回数字的类型（如果是 0
无法识别），否则它是 IS_NUMBER_IN_UV 的位或组合，
IS_NUMBER_GREATER_THAN_UV_MAX、IS_NUMBER_NOT_INT、IS_NUMBER_NEG、
IS_NUMBER_INFINITY、IS_NUMBER_NAN（在 perl.h 中定义）。

如果数字的值可以适合 UV，则在 *valuep 中返回
IS_NUMBER_IN_UV 将设置为表示 *valuep 有效，IS_NUMBER_IN_UV
除非 *valuep 有效，否则永远不会设置，但 *valuep 可能已分配给
在处理期间，即使返回时未设置 IS_NUMBER_IN_UV。 如果 valuep 是
NULL，IS_NUMBER_IN_UV 将设置为与 valuep 为非 NULL 时相同的情况，
但不会发生实际分配（或 SEGV）。

如果看到尾随小数，则 IS_NUMBER_NOT_INT 将设置为 IS_NUMBER_IN_UV
（在这种情况下，*valuep 给出截断为整数的真值），并且
IS_NUMBER_NEG 如果数字是负数（在这种情况下 *valuep 持有绝对
价值）。 如果使用 e 表示法或数字较大，则不设置 IS_NUMBER_IN_UV
比紫外线。

“flags”只允许“PERL_SCAN_TRAILING”，它允许尾随非数字
否则成功的文本 神交，在结果上设置“IS_NUMBER_TRAILING”。

int grok_number_flags(const char *pv, STRLEN len,
UV *valuep，U32 标志）

grok_数字_基数
扫描并跳过数字小数分隔符（基数）。

bool grok_numeric_radix(const char **sp,
常量字符 *发送）

格罗克_八月
将表示八进制数的字符串转换为数字形式。

入境时 开始 和 * len 给出要扫描的字符串， *标志 给出转换标志，
和 导致 应该是 NULL 或指向 NV 的指针。 扫描在结束时停止
字符串，或第一个无效字符。 除非设置了“PERL_SCAN_SILENT_ILLDIGIT”
in *标志，遇到 8 或 9 也会触发警告。 返回时 * len is
设置为扫描字符串的长度，并且 *标志 给出输出标志。

如果值 <= UV_MAX 它作为 UV 返回，输出标志是清晰的，并且
没有写入任何内容 * 结果. 如果值 > UV_MAX "grok_oct" 返回
UV_MAX，在输出标志中设置“PERL_SCAN_GREATER_THAN_UV_MAX”，并写入
价值 * 结果 （或者如果该值被丢弃 导致 一片空白）。

如果“PERL_SCAN_ALLOW_UNDERSCORES”设置在 *标志 那么八进制数可以使用
'_' 字符来分隔数字。

UV grok_oct(const char* start,STRLEN* len_p,
I32* 标志，NV *结果）

伊辛夫南
Perl_isinfnan() 是实用函数，如果 NV 参数是，则返回 true
无穷大或 NaN，否则为假。 要更详细地测试，请使用 Perl_isinf()
和 Perl_isnan().

这也是逻辑上的逆 Perl_isfinite().

布尔 isinfnan(NV nv)

Perl_符号位
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

如果设置了 NV 上的符号位，则返回一个非零整数，否则返回 0。

如果 Configure 检测到此系统有 符号位（） 这将适用于我们的 NV，然后
我们只是通过 perl.h 中的#define 来使用它。 否则，回到这个
执行。 这个函数的主要用途是捕捉-0.0。

配置说明：这个函数被称为 'Perl_signbit' 而不是一个普通的
'signbit' 因为很容易想象一个系统有一个 符号位（） 功能或
碰巧不适用于我们特定选择的 NV 的宏。 我们不应该
只需将#define signbit 重新定义为 Perl_signbit 并期望标准系统头文件
要开心。 此外，这是一个无上下文函数（无 pTHX_），因为 Perl_符号位()
通常在 perl.h 中重新#定义为对系统的简单宏调用 符号位（）.
用户应该总是打电话 Perl_符号位().

int Perl_signbit（NV f）

扫描箱
为了向后兼容。 请改用“grok_bin”。

NV scan_bin(const char* start, STRLEN len,
STRLEN* 重新调整）

扫描十六进制
为了向后兼容。 请改用“grok_hex”。

NV scan_hex(const char* 开始, STRLEN len,
STRLEN* 重新调整）

扫描八进制
为了向后兼容。 请改用“grok_oct”。

NV scan_oct(const char* start,STRLEN len,
STRLEN* 重新调整）

过时的 向后 兼容性 功能

其中一些也已被弃用。 您可以通过以下方式从编译的 Perl 中排除这些
将此选项添加到配置：“-Accflags='-DNO_MATHOMS'”

自定义操作描述
返回给定自定义操作的描述。 这曾经被 OP_DESC 使用过
宏，但不再是：它只是为了兼容性而保留的，不应该
使用。

const char * custom_op_desc(const OP *o)

自定义操作名称
返回给定自定义操作的名称。 这曾经被 OP_NAME 宏使用过，
但不再是：它只是为了兼容性而保留的，不应使用。

const char * 自定义操作名称(const OP *o)

gv_fetch 方法
请参阅“gv_fetchmethod_autoload”。

GV* gv_fetchmethod(HV* stash, const char* 名称)

is_utf8_char
已弃用！ 计划从 Perl 的未来版本中删除此功能。
不要将它用于新代码； 从现有代码中删除它。

测试一些任意数量的字节是否以有效的 UTF-8 字符开头。 笔记
INVARIANT（即非 EBCDIC 机器上的 ASCII）字符是有效的 UTF-8
特点。 将返回 UTF-8 字符中的实际字节数，如果
有效，否则为 0。

由于格式错误的输入可能会导致此功能已被弃用
导致读取超出输入缓冲区的末尾。 请改用“isUTF8_CHAR”。

STRLEN is_utf8_char(const U8 *s)

is_utf8_char_buf
这与宏“isUTF8_CHAR”相同。

STRLEN is_utf8_char_buf(const U8 *buf,
常量 U8 *buf_end)

包猫
执行引擎 盒（） Perl 函数。 注意：参数 next_in_list 和
不使用标志。 不应使用此调用； 改用包列表。

void pack_cat(SV *cat, const char *pat,
const char *patend，SV **beglist，
SV **endlist，SV ***next_in_list，
U32 标志）

pad_compname_type
在位置查找词法变量的类型 po 在目前——
编译垫。 如果变量是类型化的，则它所在的类的存储
类型被返回。 如果不是，则返回“NULL”。

HV * pad_compname_type(PADOFFSET po)

sv_2pvbyte_nolen
返回指向 SV 的字节编码表示的指针。 可能导致 SV
作为副作用从 UTF-8 降级。

通常通过“SvPVbyte_nolen”宏访问。

字符* sv_2pvbyte_nolen(SV* sv)

sv_2pvutf8_nolen
返回指向 SV 的 UTF-8 编码表示的指针。 可能导致 SV
作为副作用升级到 UTF-8。

通常通过“SvPVutf8_nolen”宏访问。

字符* sv_2pvutf8_nolen(SV* sv)

sv_2pv_nolen
像“sv_2pv()”，但也不返回长度。 您通常应该使用
宏包装器“SvPV_nolen(sv)”。

字符* sv_2pv_nolen(SV* sv)

sv_catpvn_mg
像“sv_catpvn”，但也处理“设置”魔法。

void sv_catpvn_mg(SV *sv, const char *ptr,
斯特伦）

sv_catsv_mg
像“sv_catsv”，但也处理“设置”魔法。

无效 sv_catsv_mg(SV *dsv, SV *ssv)

sv_force_normal
撤消对 SV 的各种伪造：如果 PV 是共享字符串，则创建一个
私人副本； 如果我们是裁判，请停止裁判； 如果我们是 glob，请降级为 xpvmg。
另见“sv_force_normal_flags”。

无效 sv_force_normal(SV *sv)

sv_iv “SvIVx”宏的私有实现，用于无法处理的编译器
复杂的宏表达式。 始终使用宏。

IV sv_iv(SV* sv)

sv_无锁定
当不存在锁定模块时“锁定”SV 的虚拟例程。 存在
避免测试 NULL 函数指针，因为它可能会发出警告
在某种程度的严格性下。

被“取代” sv_nosharing().

无效 sv_nolocking(SV *sv)

sv_名词解锁
当不存在锁定模块时“解锁”SV 的虚拟例程。
存在是为了避免对 NULL 函数指针进行测试，并且因为它可能潜在地
在某种严格程度下发出警告。

被“取代” sv_nosharing().

无效 sv_nounlocking(SV *sv)

sv_nv “SvNVx”宏的私有实现，用于无法处理的编译器
复杂的宏表达式。 始终使用宏。

NV sv_nv(SV* sv)

sv_pv 使用“SvPV_nolen”宏代替

字符* sv_pv(SV *sv)

sv_pvbyte
请改用“SvPVbyte_nolen”。

字符* sv_pvbyte(SV *sv)

sv_pvbyten
无法应对的编译器的“SvPVbyte”宏的私有实现
具有复杂的宏表达式。 始终使用宏。

char* sv_pvbyten(SV *sv, STRLEN *lp)

sv_pvn “SvPV”宏的私有实现，用于无法处理的编译器
复杂的宏表达式。 始终使用宏。

char* sv_pvn(SV *sv, STRLEN *lp)

sv_pvutf8
改用“SvPVutf8_nolen”宏

字符* sv_pvutf8(SV *sv)

sv_pvutf8n
无法应对的编译器的“SvPVutf8”宏的私有实现
具有复杂的宏表达式。 始终使用宏。

字符* sv_pvutf8n(SV *sv, STRLEN *lp)

sv_污点
污染 SV。 请改用“SvTAINTED_on”。

无效 sv_taint(SV* sv)

sv_unref
取消设置 SV 的 RV 状态，并减少任何之前的引用计数
被 RV 引用。 这几乎可以被认为是一个逆转
“新SVrv”。 这是“sv_unref_flags”，“flag”为零。 请参见“SvROK_off”。

无效 sv_unref(SV* sv)

sv_usepvn
告诉 SV 使用“ptr”来查找其字符串值。 通过调用实现
“sv_usepvn_flags”，“flags”为 0，因此不处理“set”魔法。 看
“sv_usepvn_flags”。

void sv_usepvn（SV* sv，char* ptr，STRLEN len）

sv_usepvn_mg
像“sv_usepvn”，但也处理“设置”魔法。

void sv_usepvn_mg（SV *sv，char *ptr，STRLEN len）

sv_uv “SvUVx”宏的私有实现，用于无法处理的编译器
复杂的宏表达式。 始终使用宏。

紫外线 sv_uv(SV* sv)

解压字符串
执行引擎 解包（） Perl 函数。 注意：参数strbeg，new_s
和 ocnt 不使用。 不应使用此调用，请改用 unpackstring。

I32 unpack_str(const char *pat, const char *patend,
常量字符 *s，常量字符 *strbeg，
const char *strend, char **new_s,
I32 八进制，U32 标志）

utf8_to_uvchr
已弃用！ 计划从 Perl 的未来版本中删除此功能。
不要将它用于新代码； 从现有代码中删除它。

返回字符串“s”中第一个字符的本机代码点，即
假定为 UTF-8 编码； “retlen”将被设置为长度，以字节为单位，
那个性格。

检测到一些（但不是全部）UTF-8 畸形，事实上，一些畸形
输入可能会导致读取超出输入缓冲区的末尾，这就是为什么
功能已弃用。 请改用“utf8_to_uvchr_buf”。

如果“s”指向检测到的错误之一，并且启用了 UTF8 警告，
返回零并将 *retlen 设置（如果“retlen”不为 NULL）为 -1。 如果那些
警告关闭，如果定义明确，则计算值（或 Unicode REPLACEMENT
CHARACTER，如果不是的话）被静默返回，并且 *retlen 被设置（如果 "retlen" 不是
NULL) 使得 ("s" + *retlen) 是 "s" 中下一个可能的位置
开始一个非格式错误的字符。 请参阅“utf8n_to_uvchr”了解何时
返回替换字符。

UV utf8_to_uvchr(const U8 *s, STRLEN *retlen)

utf8_to_uvuni
已弃用！ 计划从 Perl 的未来版本中删除此功能。
不要将它用于新代码； 从现有代码中删除它。

返回字符串“s”中第一个字符的 Unicode 代码点，即
假定为 UTF-8 编码； “retlen”将被设置为长度，以字节为单位，
那个性格。

检测到一些（但不是全部）UTF-8 畸形，事实上，一些畸形
输入可能导致读取超出输入缓冲区的末尾，这是原因之一
为什么不推荐使用此功能。 另一个是只在极其有限的
在 Unicode 与本机代码点的情况下，应该对哪些情况感兴趣
你。 有关替代方案，请参阅“utf8_to_uvuni_buf”。

如果“s”指向检测到的错误之一，并且启用了 UTF8 警告，
返回零并将 *retlen 设置（如果“retlen”不指向 NULL）为 -1。 如果
这些警告关闭，计算值（如果定义明确）（或 Unicode
REPLACEMENT CHARACTER，如果不是的话）被静默返回，并且 *retlen 被设置（如果
"retlen" 不是 NULL)，因此 ("s" + *retlen) 是 "s" 中的下一个可能位置
这可能会开始一个非格式错误的字符。 有关详细信息，请参阅“utf8n_to_uvchr”
当 REPLACEMENT CHARACTER 返回时。

UV utf8_to_uvuni（con​​st U8 *s，STRLEN *retlen）

奥普特里 结构

新分配
构造、检查并返回一个赋值操作。 左 和 右 提供
赋值参数； 它们被此功能消耗并成为一部分
构造的操作树。

If 类型 是“OP_ANDASSIGN”、“OP_ORASSIGN”或“OP_DORASSIGN”，那么一个合适的
条件optree被构造。 如果 类型 是二元运算符的操作码，
如“OP_BIT_OR”，则构造一个执行二元运算的op
并将结果分配给左参数。 不管怎样，如果 类型 非零
然后 标志 没有效果。

If 类型 为零，则构造一个普通的标量或列表赋值。 哪一个
它的分配类型是自动确定的。 标志 给出八位
“op_flags”，除了“OPf_KIDS”将自动设置，并且，向上移动
八位，“op_private”的八位，除了值为 1 或 2 的位
根据需要自动设置。

OP * newASSIGNOP(I32 标志, OP *left, I32 optype,
OP *对）

新BINOP
构造、检查并返回任何二进制类型的操作。 类型 是操作码。
标志 给出“op_flags”的八位，除了“OPf_KIDS”将被设置
自动，并且，向上移动八位，“op_private”的八位，除了
根据需要自动设置值为 1 或 2 的位。 第一 和 最后
提供最多两个操作作为二元操作的直接子代； 他们被消耗
通过这个函数并成为构造的操作树的一部分。

OP * newBINOP(I32 类型，I32 标志，OP *first，
OP *最后）

新康多普
构造、检查并返回条件表达式 ("cond_expr") op。 标志
给出“op_flags”的八位，除了“OPf_KIDS”将被设置
自动，并且，向上移动八位，“op_private”的八位，除了
自动设置值为 1 的位。 第一 提供表达式
在两个分支之间进行选择，以及 真操作 和 错误操作 供应树枝；
它们被此函数消耗并成为构造的操作树的一部分。

OP * newCONDOP（I32 标志，OP *first，OP *trueop，
操作 *假操作）

新的DEFSVOP
构造并返回一个访问 $_ 的操作，或者作为词法变量（如果
在当前范围内声明为“我的 $_”）或全局 $_。

OP * newDEFSVOP()

新FOROP
构造、检查并返回表示“foreach”循环（迭代
通过值列表）。 这是一个重量级循环，其结构允许
通过“last”等退出循环。

sv 可选地提供将依次别名给每个项目的变量； 如果
null，默认为 $_（词法或全局）。 表达式 提供清单
要迭代的值。 阻止 提供循环的主体，并且 续
可选地提供一个“继续”块，作为主体的后半部分。
所有这些 optree 输入都被这个函数消耗并成为
构造的操作树。

标志 给出“leaveloop”操作的八位“op_flags”，并向上移动
八位，“离开循环”操作的“op_private”的八位，除了（在
两种情况）一些位将被自动设置。

OP * newFOROP（I32 标志，OP *sv，OP *expr，OP *block，
OP *续）

新GIVENOP
构造、检查并返回表示“给定”块的操作树。 COND
提供将在本地分配给词法变量的表达式，以及
阻止 提供“给定”构造的主体； 他们被这个消耗
函数并成为构造的操作树的一部分。 defsv_off 是焊盘偏移
将受到影响的标量词汇变量。 如果为 0，则全局 $_
将被使用。

OP * newGIVENOP(OP *cond, OP *block,
PADOFFSET defsv_off)

newGVOP 构造、检查并返回涉及嵌入式的任何类型的操作
参考 GV。 类型 是操作码。 标志 给出“op_flags”的八位.
gv 标识操作应引用的 GV； 调用这个函数不会
转让对它的任何引用的所有权。

OP * newGVOP（I32 类型，I32 标志，GV *gv）

新LISTOP
构造、检查并返回任何列表类型的操作。 类型 是操作码。
标志 给出“op_flags”的八位，除了“OPf_KIDS”将被设置
如果需要，自动。 第一 和 最后 提供最多两个操作是直接的
列表 op 的孩子； 它们被此功能消耗并成为
构造的操作树。

对于大多数列表运算符，检查功能希望所有子操作都存在
已经，所以调用“newLISTOP(OP_JOIN, ...)”（例如）是不合适的。 你什么
在这种情况下想要做的是创建一个 OP_LIST 类型的操作，将更多的子级附加到
它，然后调用“op_convert_list”。 有关详细信息，请参阅“op_convert_list”。

OP * newLISTOP(I32 类型，I32 标志，OP *first，
OP *最后）

新LOGOP
构造、检查并返回一个逻辑（流控制）操作。 类型 是操作码。
标志 给出“op_flags”的八位，除了“OPf_KIDS”将被设置
自动，并且，向上移动八位，“op_private”的八位，除了
自动设置值为 1 的位。 第一 提供表达式
控制流量，以及 other 提供操作的侧（替代）链； 他们
被此函数消耗并成为构造的操作树的一部分。

OP * newLOGOP(I32 类型, I32 标志, OP *first,
OP *其他）

新循环
构造、检查并返回一个退出循环的操作（例如“goto”或“last”）。
类型 是操作码。 标签 提供确定目标的参数
操作； 它被此函数消耗并成为构造的操作树的一部分。

OP * newLOOPEX（I32 类型，OP *标签）

新循环
构造、检查并返回表示循环的操作树。 这只是一个循环
在通过操作树的控制流中； 它没有重量级循环
允许通过“last”等退出循环的结构。 标志 给出了
顶级操作的八位“op_flags”，除了一些位将被设置
自动根据需要。 表达式 提供表达式控制循环
迭代，和 阻止 提供循环体； 他们被这个消耗
函数并成为构造的操作树的一部分。 可调试的 目前
未使用，应始终为 1。

OP * newLOOPOP（I32 标志，I32 可调试，OP *expr，
OP *块）

新方法
构造、检查并返回方法类型的操作，方法名称已评估
在运行时。 类型 是操作码。 标志 给出“op_flags”的八位，除了
“OPf_KIDS”将被自动设置，并且，向上移动八位，八
“op_private”的位，除了自动设置值为 1 的位。
动态方法 提供一个评估方法名称的操作； 它被这个消耗
函数并成为构造的操作树的一部分。 支持的操作类型：
操作方法。

OP * newMETHOP（I32 类型，I32 标志，OP *first）

新METHOP_named
构造、检查并返回具有常量方法名称的方法类型的操作。
类型 是操作码。 标志 给出“op_flags”的八位，并且，向上移动
八位，“op_private”的八位。 常量方法 提供常量方法
姓名; 它必须是共享的 COW 字符串。 支持的操作类型：OP_METHOD_NAMED。

OP * newMETHOP_named（I32 类型，I32 标志，
SV *const_meth)

新的NULLLIST
构造、检查并返回一个新的“存根”操作，它表示一个空列表
表达。

操作 * newNULLLIST()

newOP 构造、检查并返回任何基本类型的操作（任何没有额外
字段）。 类型 是操作码。 标志 给出“op_flags”的八位，并且，
上移八位，即“op_private”的八位。

OP * newOP（I32 类型，I32 标志）

新PADOP
构造、检查并返回任何类型的操作，该操作涉及对 a 的引用
垫元素。 类型 是操作码。 标志 给出“op_flags”的八位. 一种
pad slot 是自动分配的，并且填充了 sv; 这个函数需要
对它的一个引用的所有权。

此函数仅在 Perl 已被编译为使用 ithreads 时才存在。

OP * newPADOP（I32 类型，I32 标志，SV *sv）

newPMOP 构造、检查并返回任何模式匹配类型的操作。 类型 是
操作码。 标志 给出“op_flags”的八位，并向上移动八位，
八位“op_private”。

OP * newPMOP（I32 类型，I32 标志）

newPVOP 构造、检查并返回涉及嵌入式的任何类型的操作
C 级指针 (PV)。 类型 是操作码。 标志 给出八位
“操作标志”。 pv 提供 C 级指针，该指针必须使用
"PerlMemShared_malloc"; 当操作被销毁时，内存将被释放。

OP * newPVOP(I32 类型，I32 标志，char *pv)

新范围
构造并返回一个“范围”操作，以及从属“翻转”和“翻牌”操作。
标志 给出“翻转”操作的八位“op_flags”，并向上移动八位
位，“翻转”和“范围”操作的“op_private”的八位，除了
自动设置值为 1 的位。 左 和 右 提供
控制范围端点的表达式； 他们被这个消耗
函数并成为构造的操作树的一部分。

OP * newRANGE（I32 标志，OP *left，OP *right）

新SLICEOP
构造、检查并返回一个“lslice”（列表切片）操作。 标志 给出了
八位“op_flags”，除了“OPf_KIDS”将自动设置，并且，
上移八位，即“op_private”的八位，除了具有
值 1 或 2 根据需要自动设置。 列表值 和 下标 提供
切片参数； 它们被此功能消耗并成为
构造的操作树。

OP * newSLICEOP(I32 标志，OP *下标，
操作 *listval)

新状态
构造状态操作 (COP)。 状态操作通常是“下一个状态”操作，但会
如果为当前编译的代码启用了调试，则为“dbstate”操作。 国家
op 由“PL_curcop”（或“PL_compiling”）填充。 如果 标签 是非空的，它
提供要附加到状态 op 的标签名称； 这个函数需要
指向的内存的所有权 标签, 并将释放它。 标志 给出了
状态操作的八位“op_flags”。

If o 为null，返回状态op。 否则，状态操作将与 o
进入一个“lineseq”列表操作，它被返回。 o 被这个函数消耗，并且
成为返回的操作树的一部分。

OP * newSTATEOP（I32 标志，char *标签，OP *o）

newSVOP 构造、检查并返回涉及嵌入式 SV 的任何类型的操作。
类型 是操作码。 标志 给出“op_flags”的八位. sv 给 SV
嵌入操作中； 这个函数拥有一个对它的引用。

OP * newSVOP（I32 类型，I32 标志，SV *sv）

newUNOP 构造、检查并返回任何一元类型的操作。 类型 是操作码。
标志 给出“op_flags”的八位，除了“OPf_KIDS”将被设置
如果需要，自动上移八位，的八位
“op_private”，除了自动设置值为 1 的位。 第一
提供一个可选操作作为一元操作的直接子代； 它被消耗
这个函数并成为构造的操作树的一部分。

OP * newUNOP（I32 类型，I32 标志，OP *first）

新UNOP_AUX
类似于“newUNOP”，但创建一个 UNOP_AUX 结构，使用 op_aux
初始化为 aux

OP* newUNOP_AUX(I32 类型，I32 标志，OP* 第一，
UNOP_AUX_item *aux)

新WHENOP
构造、检查并返回表示“何时”块的操作树。 COND
提供测试表达式，并且 阻止 提供将被执行的块
如果测试评估为真； 它们被此功能消耗并成为一部分
构造的操作树。 COND 将被 DWIMically 解释为
与 $_ 进行比较，并且可能为 null 以生成“默认”块。

OP * newWHENOP(OP *cond, OP *block)

新WHILEOP
构造、检查并返回表示“while”循环的操作树。 这是一个
重量级循环，其结构允许通过“最后”退出循环和
类似的。

循环 是在循环中使用的可选预构建“enterloop”操作； 如果是
null 则将自动构建合适的操作。 表达式 提供
循环的控制表达式。 阻止 提供循环的主体，并且 续
可选地提供一个“继续”块，作为主体的后半部分。
所有这些 optree 输入都被这个函数消耗并成为
构造的操作树。

标志 给出“leaveloop”操作的八位“op_flags”，并向上移动
八位，“离开循环”操作的“op_private”的八位，除了（在
两种情况）一些位将被自动设置。 可调试的 当前未使用
并且应该始终为 1。 有我的 可以提供为 true 以强制循环体
被封闭在自己的范围内。

OP * newWHILEOP(I32 标志，I32 可调试，
LOOP *循环，OP *expr，OP *块，
OP *续，I32 has_my)

奥普特里 操作 功能

alloccopstash
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

仅在线程构建下可用，此函数在
“PL_stashpad”表示传递给它的存储。

PADOFFSET allocopstash(HV *hv)

块结束
处理编译时范围退出。 地板 是由返回的保存堆栈索引
“block_start”，和 以次 是块的主体。 返回块，可能
修改的。

OP * block_end(I32 楼层, OP *seq)

块开始
处理编译时范围条目。 安排在块退出时恢复提示
并且还处理填充序列号以使词法变量范围正确。
返回用于“block_end”的保存堆栈索引。

int block_start（int full）

ck_entersub_args_list
执行“entersub”操作树的参数部分的默认修复。 这
包括将列表上下文应用于每个参数操作。 这是
用于标有“&”的调用、方法调用或调用的标准处理
通过子例程引用，或任何其他不能被调用者的调用
在编译时识别，或者被调用者没有原型的调用。

OP * ck_entersub_args_list（OP *entersubop）

ck_entersub_args_proto
基于 a 执行“entersub”操作树的参数部分的修复
子程序原型。 这对参数 ops 进行了各种修改，从
将上下文应用到插入“refgen”操作，并检查数字和
语法类型的参数，由原型指示。 这是标准
子程序调用上使用的处理，没有用“&”标记，被调用者可以是
在编译时确定并具有原型。

原型 提供要应用于调用的子例程原型。 它可能是一个
正常定义的标量，将使用其中的字符串值。 或者，对于
方便，它可能是一个子程序对象（一个“CV*”已经被转换为“SV*”）
它有一个原型。 所提供的原型，无论以何种形式，都不需要
匹配操作树引用的实际被调用者。

如果参数 ops 不同意原型，例如有一个
不可接受的参数数量，无论如何都会返回一个有效的操作树。 错误
反映在解析器状态中，通常会在
顶级解析，涵盖所有发生的编译错误。 在
错误消息，被调用者由定义的名称引用 名称gv
参数。

OP * ck_entersub_args_proto（OP *entersubop，
GV *namegv，SV *protosv)

ck_entersub_args_proto_or_list
执行“entersub”操作树的参数部分的修复，或者基于
子例程原型或使用默认列表上下文处理。 这是
用于子例程调用的标准处理，未标有“&”，其中
被调用者可以在编译时被识别。

原型 提供要应用于调用的子例程原型，或指示
没有原型。 它可能是一个正常的标量，在这种情况下，如果它是
已定义，则字符串值将用作原型，如果未定义
那么就没有原型了。 或者，为方便起见，它可能是
子程序对象（一个被转换为“SV*”的“CV*”），它的原型
如果它有一个将被使用。 提供的原型（或缺少原型），在
无论哪种形式，都不需要匹配 op 引用的实际被调用者
树。

如果参数 ops 不同意原型，例如有一个
不可接受的参数数量，无论如何都会返回一个有效的操作树。 错误
反映在解析器状态中，通常会在
顶级解析，涵盖所有发生的编译错误。 在
错误消息，被调用者由定义的名称引用 名称gv
参数。

OP * ck_entersub_args_proto_or_list（OP *entersubop，
GV *名称gv，
SV *protosv)

CV_const_sv
如果“cv”是符合内联条件的常量子，则返回常量值
由子返回。 否则，返回 NULL。

可以使用“newCONSTSUB”或如“Constant”中所述创建常量子
perlsub 中的函数”。

SV* cv_const_sv(const CV *const cv)

cv_get_call_checker
检索将用于修复调用的函数 cv。 特别，
该函数应用于子例程调用的“entersub”操作树，未标记
使用“&”，其中被调用者可以在编译时标识为 cv.

C 级函数指针在 *ckfun_p, 它的 SV 参数是
返回 *ckobj_p. 该函数旨在以这种方式调用：

Entersubop = (*ckfun_p)(aTHX_ Entersubop, namegv, (*ckobj_p));

在这次通话中， 进入subop 是指向“entersub”操作的指针，它可以被替换
通过检查功能，和 名称gv 是一个提供应该使用的名称的 GV
如果需要，通过检查函数来引用“entersub”操作的被调用者
发出任何诊断。 允许在非标准中应用校验功能
情况，例如调用不同的子例程或方法调用。

默认情况下，函数是 Perl_ck_entersub_args_proto_or_list，而 SV
参数是 cv 本身。 这实现了标准原型处理。 有可能
对于特定的子程序，由“cv_set_call_checker”更改。

无效 cv_get_call_checker(CV *cv,
Perl_call_checker *ckfun_p，
SV **ckobj_p)

cv_set_call_checker
“cv_set_call_checker_flags”的原始形式，它传递给它
向后兼容的“CALL_CHECKER_REQUIRE_GV”标志。

无效 cv_set_call_checker(CV *cv,
Perl_call_checker ckfun，
SV *ckobj)

cv_set_call_checker_flags
设置将用于修复调用的函数 cv。 具体来说，
函数应用于子例程调用的“entersub”操作树，未标记
使用“&”，其中被调用者可以在编译时标识为 cv.

C 级函数指针在 快玩, 它的 SV 参数是
提供 对象. 函数应该这样定义：

静态 OP * ckfun(pTHX_ OP *op, GV *namegv, SV *ckobj)

它打算以这种方式调用：

entersubop = ckfun（aTHX_ entersubop，namegv，ckobj）；

在这次通话中， 进入subop 是指向“entersub”操作的指针，它可以被替换
通过检查功能，和 名称gv 提供应该由
检查函数以引用“entersub”操作的被调用者是否需要发出任何
诊断。 允许在非标准中应用校验功能
情况，例如调用不同的子例程或方法调用。

名称gv 实际上可能不是GV。 为了提高效率，perl 可能会传递一个 CV 或其他 SV
反而。 无论传递什么都可以用作“cv_name”的第一个参数。 你
可以强制 perl 通过在 标志.

可以通过“cv_get_call_checker”检索特定 CV 的当前设置。

无效 cv_set_call_checker_flags(
CV *cv，Perl_call_checker ckfun，SV *ckobj，
U32 标志
)

链接列表
给定 optree 的根，使用“op_next”按执行顺序链接树
指针并返回执行的第一个操作。 如果这已经完成，它将
不重做，将返回“o->op_next”。 如果“o->op_next”还没有
组， o 至少应该是“UNOP”。

OP* 链接列表（OP *o）

新CONSTSUB
参见“newCONSTSUB_flags”。

CV* newCONSTSUB(HV* 存储，const char* 名称，SV* sv)

新CONSTSUB_flags
创建一个等价于 Perl "sub FOO () { 123 }" 的常量 sub 符合条件
用于在编译时内联。

目前，“标志”唯一有用的值是 SVf_UTF8。

新创建的子例程拥有对传入 SV 的引用的所有权。

为 SV 传递 NULL 会创建一个等价于“sub BAR () {}”的常量 sub，它
如果用作析构函数，则不会被调用，但会抑制调用的开销
到“自动加载”。 （但是，这种形式在编译时不适合内联。）

CV* newCONSTSUB_flags(HV* stash, const char* 名称,
STRLEN len，U32 标志，SV* sv)

newXS 由“xsubpp”用来将 XSUB 连接为 Perl 子。 文件名 必须是静态的
存储，因为它直接用作 简历文件（）, 没有制作副本。

OPHAS_SIBLING
如果 o 有兄弟，则返回 true

布尔 OpHAS_SIBLING(OP *o)

OpLASTSIB_set
将 o 标记为没有其他兄弟姐妹。 在“PERL_OP_PARENT”构建中，将 o 标记为
有指定的父母。 另见“OpMORESIB_set”和“OpMAYBESIB_set”。 为一个
更高级别的接口，请参阅“op_sibling_splice”。

无效 OpLASTSIB_set(OP *o, OP *parent)

OpMAYBESIB_set
有条件地执行“OpMORESIB_set”或“OpLASTSIB_set”，具体取决于 sib 是否为
非空。 对于更高级别的接口，请参见“op_sibling_splice”。

无效 OpMAYBESIB_set(OP *o, OP *sib, OP *parent)

OpMORESIB_set
将 o 的兄弟设置为非零值 sib。 另见“OpLASTSIB_set”和
“OpMAYBESIB_set”。 对于更高级别的接口，请参见“op_sibling_splice”。

无效 OpMORESIB_set(OP *o, OP *sib)

操作
返回 o 的兄弟，如果没有兄弟，则返回 NULL

OP* OpSIBLING(OP *o)

op_append_elem
将一个项目附加到直接包含在列表类型操作中的操作列表中，
返回加长列表。 第一 是列表类型的操作，并且 最后 是选项
附加到列表中。 类型 指定列表的预期操作码。 如果 第一
还不是正确类型的列表，它将被升级为一个。 如果要么
第一 or 最后 为 null，另一个则原样返回。

OP * op_append_elem（I32 optype，OP *第一个，OP *最后）

操作附加列表
连接两个列表类型操作中直接包含的操作列表，
返回组合列表。 第一 和 最后 是要连接的列表类型操作。
类型 指定列表的预期操作码。 如果要么 第一 or 最后 是不是
已经是正确类型的列表，它将被升级为一个。 如果要么 第一
or 最后 为 null，另一个则原样返回。

OP * op_append_list（I32 optype，OP *第一个，OP *最后）

OP_CLASS
返回提供的 OP 的类：即它使用哪个 *OP 结构。
对于核心操作，这目前从 PL_opargs 中获取信息，而
始终准确反映所使用的类型。 对于自定义操作，类型从返回
注册，并由注册人确保其准确无误。 这
返回的值将是 op.h 中的 OA_* 常量之一。

U32 OP_CLASS(OP *o)

op_contextualize
将句法上下文应用于表示表达式的操作树。 o 是操作
树，和 上下文 必须是“G_SCALAR”、“G_ARRAY”或“G_VOID”来指定
要应用的上下文。 返回修改后的操作树。

OP * op_contextualize(OP *o, I32 上下文)

op_convert_list
转换 o 如果它不是一个列表操作，然后将其转换为
指定 类型，调用它的检查函数，如果需要，分配一个目标，
和折叠常数。

列表类型的操作通常通过“newLISTOP”一次构造一个孩子，
“op_prepend_elem”和“op_append_elem”。 然后最后传递给
"op_convert_list" 使其成为正确的类型。

OP * op_convert_list（I32 类型，I32 标志，OP *o）

OP_DESC 返回提供的 OP 的简短描述。

常量字符 * OP_DESC(OP *o)

op_free 释放一个操作。 仅当不再从任何 optree 链接到 op 时才使用此选项。

无效 op_free(OP *o)

操作链接列表
该函数是“LINKLIST”宏的实现。 不应该
直接调用。

OP* op_linklist(OP *o)

操作左值
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将左值（“可修改”）上下文传播到操作及其子项。 类型
表示上下文类型，大致基于将执行的操作的类型
修改，虽然“local()”用OP_NULL表示，因为它没有op类型
它自己的（它由左值操作上的标志发出信号）。

该函数检测到不能修改的东西，比如“$x+1”，并生成
他们的错误。 例如，“$x+1 = 2”会导致它被一个操作调用
OP_ADD 类型和 OP_SASSIGN 的“类型”参数。

它还标记需要在左值上下文中特别表现的事物，例如
"$$x = 5" 这可能需要激活 $x 中的引用。

OP * op_lvalue(OP *o, I32 类型)

OP_NAME 返回提供的 OP 的名称。 对于核心操作，这会从
操作类型； 来自 op_ppaddr 的自定义操作。

常量字符 * OP_NAME(OP *o)

op_null 在不再需要某个操作时将其中和，但仍与其他操作相关联
操作。

无效 op_null(OP *o)

操作父级
如果它有父级，则返回 o 的父级 OP。 否则返回 NULL。 这
该功能仅在使用“-DPERL_OP_PARENT”构建的 perls 上可用。

OP* op_parent(OP *o)

op_prepend_elem
将项目添加到直接包含在列表类型操作中的操作列表中，
返回加长列表。 第一 是要添加到列表的操作，并且 最后
是列表类型的操作。 类型 指定列表的预期操作码。 如果 最后
还不是正确类型的列表，它将被升级为一个。 如果要么
第一 or 最后 为 null，另一个则原样返回。

OP * op_prepend_elem（I32 optype，OP *first，OP *last）

操作范围
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

用一些额外的操作包装一个操作树，以便在运行时动态范围
将被创建。 原始操作在新的动态范围内运行，然后，
只要它们正常退出，范围就会展开。 额外的操作
用于创建和展开动态范围通常是“进入”/“离开”
对，但如果操作足够简单，可以使用“范围”操作代替
需要完整的动态范围结构。

OP * op_scope(OP *o)

op_sibling_splice
用于编辑现有 op_sibling 链结构的通用函数
节点。 类比 perl 级别 拼接（） 功能，允许您删除
零个或多个顺序节点，用零个或多个不同的节点替换它们。
在父节点上执行必要的 op_first/op_last 内务管理，并
op_sibling 对孩子的操作。 最后删除的节点将被标记为
通过将 op_sibling/op_sibparent 或 op_moresib 字段更新为最后一个节点
适当。

注意 op_next 没有被操作，节点也没有被释放； 那就是
调用者的责任。 它也不会为空创建一个新的列表操作
清单等； 使用更高级别的功能，例如 op_append_elem() 对于这一点。

parent 是兄弟链的父节点。 如果
拼接不会影响链中的第一个或最后一个操作。

start 是要拼接的第一个节点之前的节点。 跟随它的节点
将被删除，并在其后插入操作。 如果为NULL，则第一个节点
onwards 被删除，并在开头插入节点。

del_count 是要删除的节点数。 如果为零，则不删除任何节点。 如果 -1
或大于或等于剩余孩子的数量，所有剩余的孩子都是
删除。

insert 是要代替节点插入的节点链中的第一个。 如果
NULL，不插入节点。

返回已删除操作链的头部，如果没有删除操作，则返回 NULL。

例如：

返回之前的操作
------ ----- ----- --------

聚丙烯
拼接(P, A, 2, XYZ) | | 公元前
ABCD AXYZD

聚丙烯
拼接(P, NULL, 1, XY) | | 一种
ABCD XYBCD

聚丙烯
拼接(P, NULL, 3, NULL) | | 美国广播公司
ABCD D

聚丙烯
拼接(P, B, 0, XY) | | 空值
ABCD ABXYCD

有关“op_sibparent”和“op_moresib”的低级直接操作，请参见
“OpMORESIB_set”、“OpLASTSIB_set”、“OpMAYBESIB_set”。

OP* op_sibling_splice(OP *父级, OP *开始,
int del_count, OP* 插入）

OP_TYPE_IS
如果给定的 OP 不是 NULL 指针并且它是给定的类型，则返回 true。

这个宏的否定，“OP_TYPE_ISNT”也可用
“OP_TYPE_IS_NN”和“OP_TYPE_ISNT_NN”省略了 NULL 指针检查。

bool OP_TYPE_IS(OP *o, Optype 类型)

OP_TYPE_IS_OR_WAS
如果给定的 OP 不是 NULL 指针并且它是给定的类型，则返回 true
或者曾经是在被 OP_NULL 类型的 OP 替换之前。

这个宏的否定，“OP_TYPE_ISNT_AND_WASNT”也可用
"OP_TYPE_IS_OR_WAS_NN" 和 "OP_TYPE_ISNT_AND_WASNT_NN" 省略了 NULL
指针检查。

bool OP_TYPE_IS_OR_WAS(OP *o, Optype 类型)

rv2cv_op_cv
检查一个操作，该操作应在运行时识别一个子例程，并且
尝试在编译时确定它标识的子例程。 这是
通常在 Perl 编译期间用于确定原型是否可以
应用于函数调用。 CVOP 是正在考虑的操作，通常是“rv2cv”
同上。 如果可以确定，则返回指向已识别子例程的指针
静态的，如果无法确定则返回空指针
静态的。

目前，如果 RV 表示“rv2cv”，则可以静态识别子程序
是由合适的“gv”或“const”操作提供的。 “gv”操作是
如果 GV 的 CV 插槽已填充，则适用。 如果
常量值必须是指向 CV 的 RV。 这个过程的细节可能会改变
在 Perl 的未来版本中。 如果“rv2cv”操作具有“OPpENTERSUB_AMPER”标志
设置则不尝试静态识别子程序：此标志为
用于抑制子例程调用的编译时魔法，强制它使用
默认运行时行为。

If 标志 设置了“RV2CVOPCV_MARK_EARLY”位，然后处理 GV
参考被修改。 如果检查了一个 GV 并且发现它的 CV 槽是
为空，则“gv”操作设置了“OPpEARLY_CV”标志。 如果操作不是
优化掉了，CV 插槽稍后会填充一个子程序，该子程序具有
原型，该标志最终会触发警告“调用太早无法检查
原型”。

If 标志 设置了“RV2CVOPCV_RETURN_NAME_GV”位，而不是返回
指向子程序的指针 它返回一个指向 GV 的指针
在此上下文中子例程的适当名称。 通常这只是
子例程的“CvGV”，但对于匿名 (“CvANON”) 子例程
通过 GV 引用它将是引用 GV。 得到的“GV*”是
转换为“CV *”以返回。 如果没有，则照常返回空指针
静态可确定的子程序。

CV * rv2cv_op_cv（OP *cvop，U32 标志）

类型 和 开箱

装箱单
执行引擎 盒（） Perl 函数。

void packlist(SV *cat, const char *pat,
const char *patend，SV **beglist，
SV **最终名单）

解包字符串
执行引擎 解包（） Perl 函数。

使用模板 pat..patend，此函数将字符串 s..strend 解压缩为
凡人 SV 的数量，它推入 perl 参数 (@_) 堆栈（所以你
需要在调用 this 之前和之后发出“PUTBACK”和“SPAGAIN”
功能）。 它返回推送元素的数量。

strend 和 patend 指针应指向最后一个字节
每个字符串的字符。

尽管此函数在 perl 参数堆栈中返回其值，但它不会
从该堆栈中获取任何参数（因此特别是没有必要做
一个 PUSHMARK 在调用它之前，不像例如“call_pv”）。

I32 解包字符串（const char *pat，
const char *patend，const char *s，
const char *strend，U32 标志）

垫 时间 结构

简历列表
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

CV 可以将 CvPADLIST(cv) 设置为指向 PADLIST。 这是简历
暂存器，存储词法变量和操作码临时和每个线程
值。

出于这些目的，“格式”是一种简历。 eval"" 也是（除非它们不是
可以随意调用，并且总是在 eval"" 执行完成后被丢弃）。
必需的文件只是没有任何外部词法范围的评估。

XSUB 没有 CvPADLIST。 dXSTARG 从 PL_curpad 获取值，但那是
真正的呼叫者垫（其中的一个插槽由每个 entersub 分配）。 不要
如果 CV 是 XSUB（由“CvISXSUB()”确定），则获取或设置 CvPADLIST，CvPADLIST
插槽在 XSUB 中用于不同的内部目的。

PADLIST 有一个存储垫的 C 数组。

PADLIST 的第 0 个条目是一个 PADNAMELIST，它代表“名称”或
而是词法的“静态类型信息”。 a 的各个元素
PADNAMELIST 是 PADNAME。 未来的重构可能会阻止 PADNAMELIST
存储在 PADLIST 的数组中，所以不要依赖它。 请参阅“PadlistNAMES”。

PADLIST 的第 CvDEPTH 条目是一个 PAD（一个 AV），它是位于
递归到 CV 的深度。 帧 AV 的第 0 个时隙是一个 AV，它是
@_。 其他条目是变量和操作目标的存储。

遍历 PADNAMELIST 遍历所有可能的填充项。 垫槽
对于目标 (SVs_PADTMP) 和 GV 最终具有 &PL_padname_undef “名称”，而
常量槽有 &PL_padname_const “名称”（参见 pad_alloc()）。 那
使用 &PL_padname_undef 和 &PL_padname_const 是一个实现细节
可调整的。 要测试它们，请使用 "!PadnamePV(name)" 和 "PadnamePV(name)
&& !PadnameLEN(name)"，分别。

只有我/我们的变量槽获得有效名称。 其余的是操作目标/GV/常量
在编译时静态分配或解析。 这些没有
在运行时通过 eval"" 可以从 Perl 代码中查找它们的名称
我/我们的变量可以这样。 因为他们不能通过“名字”来查找，而只能通过
它们在编译时分配的索引（通常在 PL_op->op_targ 中），
为他们浪费一个名字 SV 是没有意义的。

PADNAMELIST 中的焊盘名称的 PV 包含变量的名称。
COP_SEQ_RANGE_LOW 和 _HIGH 字段形成一个范围（包括低+1..高）
名称对其有效的 cop_seq 编号。 在编译期间，这些字段可能
保存特殊值 PERL_PADSEQ_INTRO 以指示各个阶段：

COP_SEQ_RANGE_LOW_HIGH
------------------ -----
PERL_PADSEQ_INTRO 0 变量尚未引入：
{ 我的 ($x
valid-seq# PERL_PADSEQ_INTRO 变量在范围内：
{ 我的 ($x)
valid-seq# valid-seq# 编译范围完成：
{ 我的 ($x) }

对于类型化的词法，PadnameTYPE 指向类型存储。 对于“我们的”词汇，
PadnameOURSTASH 指向相关全局的 stash（这样重复
可以检测到同一包中的“我们的”声明）。 PadnameGEN 有时是
用于在编译期间存储代号。

如果在焊盘名称上设置了 PadnameOUTER，则帧 AV 中的那个槽是
REFCNT 对来自“外部”的词汇的引用。 这样的条目有时是
简称“假”。 在这种情况下，名称不使用“低”和“高”来
存储一个 cop_seq 范围，因为它在整个范围内。 取而代之的是“高级”商店
一些包含真实词汇信息的标志（是否在匿名中声明，以及
它是否能够被多次实例化？），对于假的 ANON，“低”
包含存储词法值的父垫内的索引，以
使克隆更快。

如果 'name' 是 '&'，则 PAD 中的相应条目是代表一个 CV
可能的关闭。

请注意，格式被视为 anon subs，并且每次写入时都会克隆
调用（如有必要）。

每次 我的（） 被执行，并且
在范围退出时设置。 这允许“变量 $x 不可用”警告是
在 eval 中生成，例如

{ 我的 $x = 1; 子 f { eval '$x'} } f();

对于状态变量，SVs_PADSTALE 被重载以表示“尚未初始化”，但这
内部状态存储在单独的焊盘条目中。

PADLIST * CvPADLIST(CV *cv)

帕德阵列
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

填充条目的 C 数组。

SV ** PadARRAY（垫垫）

列表数组
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

padlist 的 C 数组，包含 pad。 只能用数字下标 >=
1，因为不能保证第 0 个条目保持可用。

PAD ** PadlistARRAY(PADLIST 列表)

PadlistMAX
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

padlist 中最后分配的空间的索引。 请注意，最后一个焊盘可能
处于较早的位置。 在这种情况下，它后面的任何条目都将为 NULL。

SSize_t PadlistMAX(PADLIST 列表)

PadlistNAMES
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

与填充条目关联的名称。

PADNAMELIST * PadlistNAMES(PADLIST padlist)

PadlistNAMESARRAY
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

焊盘名称的 C 数组。

PADNAME ** PadlistNAMESARRAY(PADLIST padlist)

PadlistNAMESMAX
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

最后一个焊盘名称的索引。

SSize_t PadlistNAMESMAX(PADLIST 列表)

列表REFCNT
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

padlist 的引用计数。 目前，这始终为 1。

U32 PadlistREFCNT(PADLIST 列表)

PadMAX 注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

最后一个填充条目的索引。

SSize_t PadMAX(焊盘)

密码LEN
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

名称的长度。

STRLEN PadnameLEN(PADNAME pn)

密码列表ARRAY
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

焊盘名称的 C 数组。

PADNAME ** PadnamelistARRAY(PADNAMELIST pnl)

名字列表MAX
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

最后一个焊盘名称的索引。

SSize_t PadnamelistMAX(PADNAMELIST pnl)

名字列表REFCNT
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

焊盘名称列表的引用计数。

SSize_t PadnamelistREFCNT(PADNAMELIST pnl)

PadnamelistREFCNT_dec
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

降低焊盘名称列表的引用计数。

无效 PadnamelistREFCNT_dec(PADNAMELIST pnl)

密码PV
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

存储在焊盘名称结构中的名称。 这将为目标插槽返回 NULL。

字符 * PadnamePV(PADNAME pn)

密码REFCNT
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

焊盘名称的引用计数。

SSize_t PadnameREFCNT(PADNAME pn)

密码REFCNT_dec
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

降低焊盘名称的引用计数。

无效 PadnameREFCNT_dec(PADNAME pn)

密码SV
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将 pad 名称作为凡人 SV 返回。

SV * PadnameSV(PADNAME pn)

用户名UTF8
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

PadnamePV 是否为 UTF8。 目前，这始终是正确的。

bool PadnameUTF8(PADNAME pn)

pad_add_name_pvs
完全像“pad_add_name_pvn”，但采用文字字符串而不是
字符串/长度对。

PADOFFSET pad_add_name_pvs(const char *name, U32 标志,
HV *typestash，HV *ourstash）

pad_findmy_pvs
完全像“pad_findmy_pvn”，但采用文字字符串而不是
字符串/长度对。

PADOFFSET pad_findmy_pvs（const char *名称，U32 标志）

pad_new 创建一个新的 padlist，更新当前编译的全局变量
padlist 指向新的 padlist。 以下标志可以一起进行或运算：

padnew_CLONE 此垫用于克隆的 CV
padnew_SAVE 在保存堆栈上保存旧的全局变量
padnew_SAVESUB 还为 sub 的开始保存额外的东西

PADLIST * pad_new（int 标志）

PL_comppad
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在编译期间， this 指向包含 pad 的值部分的数组
对于当前正在编译的代码。 （在运行时，一份简历可能有很多这样的价值
数组； 在编译时只构造一个。）在运行时， this 指向
包含当前相关值的数组，用于当前-
执行代码。

PL_compad_name
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

在编译期间， this 指向包含 pad 的名称部分的数组
对于当前正在编译的代码。

PL_curpad
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

直接指向“PL_comppad”数组的主体。 （即，这是
“PAD_ARRAY（PL_comppad）”。）

每个口译员 变量

PL_modglobal
"PL_modglobal" 是一个通用的解释器全局 HV，供扩展使用
需要在每个口译员的基础上保留信息。 在紧要关头，它也可以
用作扩展的符号表以在彼此之间共享数据。 它是一个
使用以拥有
数据。

HV* PL_modglobal

PL_na 一个方便变量，通常在不关心时与“SvPV”一起使用
关于字符串的长度。 通常更有效的是要么声明一个
局部变量并使用它或使用“SvPV_nolen”宏。

STRLEN PL_na

PL_opfreehook
当非“NULL”时，每次调用该变量指向的函数
OP 以相应的 OP 作为参数被释放。 这允许扩展
释放它们在本地附加到 OP 的任何额外属性。 也很放心
首先为父 OP 开火，然后为它的孩子开火。

当您替换此变量时，最好将
可能是以前安装的钩子，你记得它在你自己的里面。

Perl_ophook_t PL_opfreehook

PL_窥视
指向每个子程序窥视孔优化器的指针。 这是一个函数
在 Perl 子例程编译结束时调用（或等效独立
一段 Perl 代码）来执行某些操作的修复并执行小规模
优化。 该函数为每个编译的子例程调用一次，
并作为唯一参数传递一个指向操作的指针，该操作是指向的入口点
子程序。 它修改了操作树。

决不能完全更换窥视孔优化器。 而是将代码添加到
它通过包装现有的优化器。 执行此操作的基本方法可以在
perlguts 中的“编译阶段 3：窥视孔优化”。 如果新代码希望
对整个子程序结构中的操作进行操作，而不仅仅是在顶部
级别，包装“PL_rpeepp”钩子可能更方便。

peep_t PL_peepp

PL_rpeepp
指向递归窥孔优化器的指针。 这是一个被调用的函数
在 Perl 子例程（或等效的独立片段）编译结束时
Perl 代码）来执行某些操作的修复并执行小规模
优化。 对于通过链接的每个操作链调用一次该函数
他们的“op_next”字段； 它被递归调用来处理每个侧链。 这是
作为唯一参数，传递了一个指向位于链头的操作的指针。
它修改了操作树。

决不能完全更换窥视孔优化器。 而是将代码添加到
它通过包装现有的优化器。 执行此操作的基本方法可以在
perlguts 中的“编译阶段 3：窥视孔优化”。 如果新代码希望
只对子程序顶层的操作进行操作，而不是在整个
结构，包装“PL_peepp”钩子可能更方便。

peep_t PL_rpeepp

PL_sv_no
这是“假”SV。 参见“PL_sv_yes”。 始终将此称为 &PL_sv_no。

SV PL_sv_no

PL_sv_undef
这是“undef” SV。 始终将此称为 &PL_sv_undef。

SV PL_sv_undef

PL_sv_yes
这是“真正的”SV。 参见“PL_sv_no”。 始终将此称为 &PL_sv_yes。

SV PL_sv_yes

REGEXP 功能

SvRX 便利宏，用于从 SV 获取 REGEXP。 这大约相当于
到以下代码段：

如果 (SvMAGICAL(sv))
mg_get(sv);
如果 (SvROK(sv))
sv = MUTABLE_SV(SvRV(sv));
如果 (SvTYPE(sv) == SVt_REGEXP)
返回 (REGEXP*) sv;

如果未找到 REGEXP*，将返回 NULL。

正则表达式 * SvRX(SV *sv)

SvRXOK 返回一个布尔值，指示 SV（或其引用的）是否为
正则表达式。

如果您想稍后使用 REGEXP* 执行某些操作，请改用 SvRX 并检查
空值。

布尔 SvRXOK(SV* sv)

堆 操作 宏

dMARK 为 XSUB 声明一个堆栈标记变量“mark”。 见“标记”和
“dORIGMARK”。

马克;

多里格马克
保存 XSUB 的原始堆栈标记。 参见“原点”。

多利格马克；

dSP 声明 XSUB 的 perl 堆栈指针的本地副本，可通过“SP”获得
宏。 参见“SP”。

DSP；

EXTEND 用于扩展 XSUB 返回值的参数堆栈。 一经使用，
保证至少有空间将“nitems”推入堆栈。

无效扩展（SP，SSize_t nitems）

MARK XSUB 的堆栈标记变量。 参见“dMARK”。

mPUSHi 将一个整数压入堆栈。 堆栈必须为该元素留出空间。 做
不要使用“TARG”。 另见“PUSHi”、“mXPUSHi”和“XPUSHi”。

无效 mPUSHi(IV iv)

mPUSHn 将一个 double 压入堆栈。 堆栈必须为该元素留出空间。 做
不要使用“TARG”。 另见“PUSHn”、“mXPUSHn”和“XPUSHn”。

无效 mPUSHn(NV nv)

mPUSHp 将字符串压入堆栈。 堆栈必须为该元素留出空间。 这
“len”表示字符串的长度。 不使用“TARG”。 另见“PUSHp”，
“mXPUSHp”和“XPUSHp”。

无效 mPUSHp(char* str, STRLEN len)

mPUSHs 将 SV 压入堆栈并使 SV 死亡。 堆栈必须有空间
这个元素。 不使用“TARG”。 另见“PUSH”和“mXPUSH”。

无效 mPUSHs(SV* sv)

mPUSHu 将一个无符号整数压入堆栈。 堆栈必须为此留出空间
元素。 不使用“TARG”。 另见“PUSHU”、“mXPUSHu”和“XPUSHu”。

void mPUSHu(UV 紫外线)

mXPUSHi 将一个整数压入堆栈，必要时扩展堆栈。 不使用
“目标”。 另见“XPUSHi”、“mPUSHi”和“PUSHi”。

无效 mXPUSHi(IV iv)

mXPUSHn 将一个 double 压入堆栈，必要时扩展堆栈。 不使用
“目标”。 另见“XPUSHn”、“mPUSHn”和“PUSHn”。

无效 mXPUSHn(NV nv)

mXPUSHp 将字符串压入堆栈，必要时扩展堆栈。 “伦”
表示字符串的长度。 不使用“TARG”。 另见“XPUSHp”，
“mPUSHp”和“PUSHp”。

void mXPUSHp(char* str, STRLEN len)

mXPUSHs 将 SV 压入堆栈，必要时扩展堆栈并使 SV 死亡。
不使用“TARG”。 另见“XPUSH”和“mPUSH”。

无效 mXPUSHs(SV* sv)

mXPUSHu 将一个无符号整数压入堆栈，必要时扩展堆栈。 做
不要使用“TARG”。 另见“XPUSHu”、“mPUSHu”和“PUSHu”。

void mXPUSHu(UV 紫外线)

原点
XSUB 的原始堆栈标记。 参见“dORIGMARK”。

POPi 从堆栈中弹出一个整数。

静脉注射POPi

POPl 从堆栈中弹出一个长字节。

长 POPl

POPn 从堆栈中弹出一个 double。

NVPOPn

POPp 从堆栈中弹出一个字符串。

字符* POPp

POP字节
从堆栈中弹出一个字符串，该字符串必须由字节组成，即字符 < 256。

char* POP字节

POPpx 从堆栈中弹出一个字符串。 与 POPp 相同。 有两个名字
历史原因。

字符* POPpx

POPs 从堆栈中弹出一个 SV。

SV* 持久性有机污染物

PUSHi 将一个整数压入堆栈。 堆栈必须为该元素留出空间。
处理“设置”魔法。 使用“TARG”，因此应调用“dTARGET”或“dXSTARG”
声明它。 不要调用多个面向“TARG”的宏来返回列表
XSUB - 请参阅“mPUSHi”。 另见“XPUSHi”和“mXPUSHi”。

无效 PUHi(IV iv)

推标
回调参数的左括号。 请参阅“PUTBACK”和 perlcall。

无效推标（SP）

PUSH凡人
将一个新的凡人 SV 压入堆栈。 堆栈必须为该元素留出空间。
不使用“TARG”。 另见“PUSHs”、“XPUSHmortal”和“XPUSHs”。

无效 PUSHmortal()

PUSHn 将一个 double 压入堆栈。 堆栈必须为该元素留出空间。 把手
'设置'魔法。 使用“TARG”，因此应调用“dTARGET”或“dXSTARG”来声明
它。 不要调用多个面向“TARG”的宏来从 XSUB 返回列表 - 请参阅
“mPUSHn”代替。 另见“XPUSHn”和“mXPUSHn”。

无效 PUSHn(NV nv)

PUSHp 将字符串压入堆栈。 堆栈必须为该元素留出空间。 这
“len”表示字符串的长度。 处理“设置”魔法。 使用“TARG”，所以
应该调用“dTARGET”或“dXSTARG”来声明它。 不要调用多个
从 XSUB 返回列表的面向“TARG”的宏 - 请参阅“mPUSHp”。 看
还有“XPUSHp”和“mXPUSHp”。

无效推（字符* str，STRLEN len）

PUSH 将 SV 推入堆栈。 堆栈必须为该元素留出空间。 才不是
处理“设置”魔法。 不使用“TARG”。 另见“PUSHmortal”、“XPUSHs”和
“XPUSH凡人”。

无效推送（SV* sv）

PUSHu 将一个无符号整数压入堆栈。 堆栈必须为此留出空间
元素。 处理“设置”魔法。 使用“TARG”，所以“dTARGET”或“dXSTARG”应该是
打电话来宣布它。 不要调用多个面向“TARG”的宏来返回列表
来自 XSUB - 请参阅“mPUSHu”。 另见“XPUSHu”和“mXPUSHu”。

void PUSH(UV uv)

PUTBACK XSUB 参数的右括号。 这通常由“xsubpp”处理。 看
"PUSHMARK" 和 perlcall 用于其他用途。

放回去;

SP 堆栈指针。 这通常由“xsubpp”处理。 参见“dSP”和“SPAGAIN”。

SPAGAIN 重新获取堆栈指针。 在回调后使用。 请参阅 perlcall。

西班牙；

XPUSHi 将一个整数压入堆栈，必要时扩展堆栈。 处理“设置”
魔法。 使用“TARG”，因此应该调用“dTARGET”或“dXSTARG”来声明它。 做
不要调用多个面向“TARG”的宏来从 XSUB 返回列表 - 请参阅
“mXPUSHi”代替。 另见“PUSHi”和“mPUSHi”。

无效 XPUSHi(IV iv)

XPUSH凡人
将一个新的凡人 SV 压入堆栈，必要时扩展堆栈。 才不是
使用“目标”。 另见“XPUSHs”、“PUSHmortal”和“PUSHs”。

无效 XPUSHmortal()

XPUSHn 将一个 double 压入堆栈，必要时扩展堆栈。 处理“设置”
魔法。 使用“TARG”，因此应该调用“dTARGET”或“dXSTARG”来声明它。 做
不要调用多个面向“TARG”的宏来从 XSUB 返回列表 - 请参阅
“mXPUSHn”代替。 另见“PUSHn”和“mPUSHn”。

无效 XPUSHn(NV nv)

XPUSHp 将字符串压入堆栈，必要时扩展堆栈。 “伦”
表示字符串的长度。 处理“设置”魔法。 使用“TARG”，所以
应该调用“dTARGET”或“dXSTARG”来声明它。 不要调用多个
面向“TARG”的宏从 XSUB 返回列表 - 请参阅“mXPUSHp”。 看
还有“PUSHp”和“mPUSHp”。

void XPUSHp(char* str, STRLEN len)

XPUSHs 将 SV 压入堆栈，必要时扩展堆栈。 不处理
'设置'魔法。 不使用“TARG”。 另见“XPUSHmortal”、“PUSHs”和
“推死”。

无效 XPUSHs(SV* sv)

XPUSHu 将一个无符号整数压入堆栈，必要时扩展堆栈。
处理“设置”魔法。 使用“TARG”，因此应调用“dTARGET”或“dXSTARG”
声明它。 不要调用多个面向“TARG”的宏来返回列表
XSUB - 请参阅“mXPUShu”。 另见“PUSHu”和“mPUSHu”。

void XPUSHU(UV uv)

返回
从 XSUB 返回，指示堆栈上的项目数。 这通常是
由“xsubpp”处理。

void XSRETURN(int nitems)

XSRETURN_EMPTY
立即从 XSUB 返回一个空列表。

XSRETURN_EMPTY；

XSRETURN_IV
立即从 XSUB 返回一个整数。 使用“XST_mIV”。

无效 XSRETURN_IV(IV iv)

XSRETURN_NO
立即从 XSUB 返回 &PL_sv_no。 使用“XST_mNO”。

XSRETURN_NO；

XSRETURN_NV
立即从 XSUB 返回一个 double。 使用“XST_mNV”。

无效 XSRETURN_NV(NV nv)

XSRETURN_PV
立即从 XSUB 返回字符串的副本。 使用“XST_mPV”。

无效 XSRETURN_PV(char* str)

XSRETURN_UNDEF
立即从 XSUB 返回 &PL_sv_undef。 使用“XST_mUNDEF”。

XSRETURN_UNDEF；

XSRETURN_UV
立即从 XSUB 返回一个整数。 使用“XST_mUV”。

void XSRETURN_UV(IV uv)

XSRETURN_YES
立即从 XSUB 返回 &PL_sv_yes。 使用“XST_mYES”。

XSRETURN_YES；

XST_mIV 将一个整数放入堆栈上的指定位置“pos”。 值为
存储在一个新的凡人 SV 中。

void XST_mIV(int pos, IV iv)

XST_mNO 将 &PL_sv_no 放入堆栈上的指定位置“pos”。

无效 XST_mNO(int pos)

XST_mNV 将一个 double 放入堆栈上的指定位置“pos”。 值为
存储在一个新的凡人 SV 中。

无效 XST_mNV(int pos, NV nv)

XST_mPV 将字符串的副本放入堆栈上的指定位置“pos”。 这
值存储在一个新的凡人 SV 中。

无效 XST_mPV(int pos, char* str)

XST_mUNDEF
将 &PL_sv_undef 放入堆栈上的指定位置“pos”。

无效 XST_mUNDEF(int pos)

XST_mYES
将 &PL_sv_yes 放入堆栈上的指定位置“pos”。

无效 XST_mYES(int pos)

SV 旗

svtype Perl 类型的标志枚举。 这些可以在文件中找到 SV.h 在“svtype”中
枚举。 使用“SvTYPE”宏测试这些标志。

类型是：

SVt_NULL
SVt_IV
SVt_NV
SVt_RV
SVt_PV
SVt_PVIV
SVt_PVNV
SVt_PVMG
SVt_INVLIST
SVt_REGEXP
SVt_PVGV
SVt_PVLV
SVt_PVAV
SVt_PVHV
SVt_PVCV
SVt_PVFM
SVt_PVIO

这些最容易自下而上地解释。

SVt_PVIO 用于 I/O 对象， SVt_PVFM 用于格式， SVt_PVCV 用于子例程，
SVt_PVHV 用于哈希，SVt_PVAV 用于数组。

所有其他都是标量类型，即可以绑定到“$”的东西
多变的。 对于这些，内部类型大多与
Perl 语言。

因此，检查“SvTYPE(sv) < SVt_PVAV”是查看某事是否
是一个标量。

SVt_PVGV 代表一个类型团。 如果 !SvFAKE(sv)，那么它是一个真实的，不可强制的
类型球。 如果 SvFAKE(sv)，那么它是一个标量
分配的。 再次分配给它会阻止它成为 typeglob。 SVt_PVLV
表示一个标量，它在幕后委托给另一个标量。 这是
例如，用于“substr”的返回值以及绑定的散列和数组元素。
它可以保存任何标量值，包括类型球。 SVt_REGEXP 用于常规
表达式。 SVt_INVLIST 仅供 Perl 核心内部使用。

SVt_PVMG 表示“正常”标量（不是类型团、正则表达式或
代表）。 由于大多数标量不需要 PVMG 的所有内部字段，我们
尽可能分配更小的结构来节省内存。 所有其他类型都是
只是更简单的 SVt_PVMG 形式，内部字段更少。
SVt_NULL 只能保存 undef。 SVt_IV 可以保存 undef、整数或引用。
（SVt_RV 是 SVt_IV 的别名，存在是为了向后兼容。） SVt_NV
可以容纳其中任何一个或双倍。 SVt_PV 只能保存 undef 或字符串。
SVt_PVIV 是 SVt_PV 和 SVt_IV 的超集。 SVt_PVNV 类似。 SVt_PVMG 可以
持有任何 SVt_PVNV 可以持有的东西，但它可以，但不必，被祝福或
神奇。

SVt_INVLIST
标量的类型标志。 参见“svtype”。

SVt_IV 标量的类型标志。 参见“svtype”。

SVt_NULL
标量的类型标志。 参见“svtype”。

SVt_NV 标量的类型标志。 参见“svtype”。

SVt_PV 标量的类型标志。 参见“svtype”。

SVt_PVAV
数组的类型标志。 参见“svtype”。

SVt_PVCV
子程序的类型标志。 参见“svtype”。

SVt_PVFM
格式的类型标志。 参见“svtype”。

SVt_PVGV
typeglob 的类型标志。 参见“svtype”。

SVt_PVHV
为哈希键入标志。 参见“svtype”。

SVt_PVIO
I/O 对象的类型标志。 参见“svtype”。

SVt_PVIV
标量的类型标志。 参见“svtype”。

SVt_PVLV
标量的类型标志。 参见“svtype”。

SVt_PVMG
标量的类型标志。 参见“svtype”。

SVt_PVNV
标量的类型标志。 参见“svtype”。

SVt_REGEXP
正则表达式的类型标志。 参见“svtype”。

SV 操作 功能

boolSV 如果“b”为真值，则返回真 SV，如果“b”为 0，则返回假 SV。

另见“PL_sv_yes”和“PL_sv_no”。

SV * boolSV(布尔 b)

croak_xs_usage
“croak()”的一个特殊变体，用于发出 xsubs 的使用消息

croak_xs_usage（简历，“eee_yow”）；

从“cv”中算出包名和子程序名，然后调用
“发牢骚（）”。 因此，如果 "cv" 是 &ouch::awk，它会将 "croak" 称为：

Perl_croak(aTHX_ "用法：%"SVf"::%"SVf"(%s)", "哎哟" "awk",
“eee_yow”）；

无效 croak_xs_usage(const CV *const cv,
const char *const 参数）

get_sv 返回指定 Perl 标量的 SV。 “标志”被传递给“gv_fetchpv”。
如果设置了“GV_ADD”并且 Perl 变量不存在，那么它将被创建。
如果“flags”为零且变量不存在，则返回 NULL。

注意：不推荐使用此函数的 perl_ 形式。

SV* get_sv(const char *name, I32 标志)

新RV_inc
为 SV 创建 RV 包装器。 原始 SV 的引用计数是
增加了。

SV* newRV_inc(SV* sv)

新SVpadname
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

创建一个包含焊盘名称的新 SV。

SV* 新SVpadname(PADNAME *pn)

新SVpvn_utf8
创建一个新的 SV 并复制一个字符串（可能包含“NUL”（“\0”）字符）
进去。 如果 utf8 为真，则在新 SV 上调用“SvUTF8_on”。 实施为
包装“newSVpvn_flags”。

SV* newSVpvn_utf8(NULLOK const char* s, STRLEN len,
U32 UTF8)

SvCUR 返回 SV 中字符串的长度。 参见“SvLEN”。

STRLEN SvCUR(SV* sv)

SvCUR_set
设置 SV 中字符串的当前长度。 参见“SvCUR”和
“SvIV_set”。

void SvCUR_set(SV* sv, STRLEN len)

SvEND 返回一个指针，指向字符串中最后一个字符之后的位置
在 SV 中，通常有一个尾随的“NUL”字符（即使 Perl
标量并不严格要求它）。 参见“SvCUR”。 访问字符为
*(SvEND(sv))。

警告：如果“SvCUR”等于“SvLEN”，则“SvEND”指向未分配
记忆。

字符* SvEND(SV* sv)

SVGAMAGIC
如果 SV 获得魔法或重载，则返回 true。 如果其中任何一个为真，那么
标量是活动数据，每次都有可能返回一个新值
被访问。 因此，您必须小心每个用户逻辑上只阅读一次
操作并使用该返回值。 如果两者都不为真，则标量的
除非写入，否则值不能更改。

U32 SvGAMAGIC(SV* sv)

SvGROW 扩展 SV 中的字符缓冲区，使其有空间容纳指定的字符缓冲区
字节数（请记住为额外的尾随“NUL”字符保留空间）。
如有必要，调用“sv_grow”来执行扩展。 返回一个指向
字符缓冲区。 SV 的类型必须 >= SVt_PV。 一种选择是调用
如果您不确定 SV 的类型，请使用“sv_grow”。

char * SvGROW(SV* sv, STRLEN len)

SvIOK 返回一个 U32 值，指示 SV 是否包含整数。

U32 SVIOK(SV* sv)

SvIOKp 返回一个 U32 值，指示 SV 是否包含整数。 检查
私立 环境。 请改用“SvIOK”。

U32 SvIOKp(SV* sv)

SvIOK_notUV
返回一个布尔值，指示 SV 是否包含有符号整数。

布尔 SvIOK_notUV(SV* sv)

SVIOK_off
取消设置 SV 的 IV 状态。

无效 SvIOK_off(SV* sv)

SvIOK_on
告诉 SV 它是一个整数。

无效 SvIOK_on(SV* sv)

仅SvIOK_
告诉 SV 它是一个整数并禁用所有其他 OK 位。

无效 SvIOK_only(SV* sv)

SvIOK_only_UV
告诉 SV 它是一个无符号整数并禁用所有其他 OK 位。

无效 SvIOK_only_UV(SV* sv)

SvIOK_UV
返回一个布尔值，指示 SV 是否包含必须为
解释为无符号。 一个非负整数，其值在范围内
IV 和 UV 都可以标记为 SvUOK 或 SVIOK。

布尔 SvIOK_UV(SV* sv)

SvIsCOW 返回一个 U32 值，指示 SV 是否为 Copy-On-Write（共享哈希
键标量，如果 5.9.0 配置为 COW，则为完整的写入时复制标量）。

U32 SvIsCOW(SV* sv)

SvIsCOW_shared_hash
返回一个布尔值，指示 SV 是否为 Copy-On-Write 共享哈希键
标量。

布尔 SvIsCOW_shared_hash(SV* sv)

SvIV 将给定的 SV 强制为一个整数并返回它。 有关版本，请参见“SvIVx”
这保证只评估 sv 一次。

IV SvIV(SV* sv)

SvIVX 返回 SV 的 IV 槽中的原始值，不进行检查或转换。 仅有的
当您确定 SvIOK 为真时使用。 另见“SvIV()”。

IV SvIVX(SV* sv)

SvIVx 将给定的 SV 强制为一个整数并返回它。 保证评估“sv”
只有一次。 仅当“sv”是具有副作用的表达式时才使用它，否则
使用更高效的“SvIV”。

IV SvIVx(SV* sv)

SVIV_nomg
像“SvIV”，但不处理魔法。

IV SvIV_nomg(SV* sv)

SvIV_set
将 sv 中的 IV 指针的值设置为 val。 可以执行相同的操作
这个宏的函数，左值赋值给“SvIVX”。 有了未来的 Perls，
但是，使用“SvIV_set”而不是左值会更有效
分配给“SvIVX”。

void SvIV_set(SV* sv, IV val)

SvLEN 返回 SV 中字符串缓冲区的大小，不包括任何部分
归因于“SvOOK”。 参见“SvCUR”。

STRLEN SvLEN(SV* sv)

SvLEN_set
设置 SV 中字符串的实际长度。 参见“SvIV_set”。

void SvLEN_set(SV* sv, STRLEN len)

SvMAGIC_set
将 sv 中的 MAGIC 指针的值设置为 val。 参见“SvIV_set”。

void SvMAGIC_set(SV* sv, MAGIC* val)

SvNIOK 返回一个 U32 值，指示 SV 是否包含数字、整数或
双。

U32 SVNIOK(SV* sv)

SvNIOKp 返回一个 U32 值，指示 SV 是否包含数字、整数或
双倍的。 检查 私立 环境。 请改用“SvNIOK”。

U32 SvNIOKp(SV* sv)

SVNIOK_off
取消设置 SV 的 NV/IV 状态。

无效 SvNIOK_off(SV* sv)

SvNOK 返回一个 U32 值，指示 SV 是否包含双精度数。

U32 SVNOK(SV* sv)

SvNOKp 返回一个 U32 值，指示 SV 是否包含双精度值。 检查
私立 环境。 请改用“SvNOK”。

U32 SvNOKp(SV* sv)

SVNOK_off
取消设置 SV 的 NV 状态。

无效 SvNOK_off(SV* sv)

SVNOK_on
告诉 SV 它是双重的。

无效 SvNOK_on(SV* sv)

仅SvNOK_
告诉 SV 它是双精度并禁用所有其他 OK 位。

无效 SvNOK_only(SV* sv)

SvNV 将给定的 SV 强制为 double 并返回。 有关版本，请参见“SvNVx”
保证只评估 sv 一次。

NV SVNV(SV* SV)

SvNVX 返回 SV 的 NV 槽中的原始值，不进行检查或转换。 仅有的
当您确定 SvNOK 为真时使用。 参见“SvNV()”。

NV SvNVX(SV* sv)

SvNVx 将给定的 SV 强制为 double 并返回它。 保证仅评估“sv”
一次。 仅当“sv”是具有副作用的表达式时才使用它，否则使用
更高效的“SvNV”。

NV SvNVx(SV* sv)

SVNV_nomg
像“SvNV”，但不处理魔法。

NV SvNV_nomg(SV* sv)

SVNV_set
将 sv 中的 NV 指针的值设置为 val。 参见“SvIV_set”。

void SvNV_set(SV* sv, NV val)

SvOK 返回一个 U32 值，指示该值是否已定义。 这只是
对标量有意义。

U32 SvOK(SV* sv)

SvOOK 返回一个 U32，指示指向字符串缓冲区的指针是否偏移。 这个
hack 在内部用于加速从开头删除字符
SVPV。 当 SvOOK 为真时，分配的字符串缓冲区的开始是
实际上是 SvPVX 之前的“SvOOK_offset()”字节。 这个偏移量曾经存储在
SvIVX，但现在存储在缓冲区的备用部分中。

U32 SvOOK(SV* sv)

SvOOK_offset
读入 LEN 从 SvPVX 回到分配的真正开始的偏移量
缓冲区，如果“sv_chop”已用于有效删除
缓冲区开头的字符。 实现为宏，它采用
地址 LEN，它必须是“STRLEN”类型。 评估 sv 不止一次。
套数 LEN 如果“SvOOK(sv)”为假，则为 0。

void SvOOK_offset(NN SV*sv, STRLEN len)

SvPOK 返回一个 U32 值，指示 SV 是否包含字符串。

U32 SvPOK(SV* sv)

SvPOKp 返回一个 U32 值，指示 SV 是否包含字符串。 检查
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 私立 环境。 请改用“SvPOK”。

U32 SvPOKp(SV* sv)

SvPOK_off
取消设置 SV 的 PV 状态。

无效 SvPOK_off(SV* sv)

SvPOK_on
告诉 SV 它是一个字符串。

无效 SvPOK_on(SV* sv)

仅SvPOK
告诉 SV 它是一个字符串并禁用所有其他 OK 位。 也会转
关闭 UTF-8 状态。

无效 SvPOK_only(SV* sv)

SvPOK_only_UTF8
告诉 SV 它是一个字符串并禁用所有其他 OK 位，然后离开
UTF-8 状态。

无效 SvPOK_only_UTF8(SV* sv)

SvPV 返回指向 SV 中的字符串的指针，或者返回 SV 的字符串化形式，如果
SV 不包含字符串。 SV 可能会将字符串化版本缓存为
“SvPOK”。 处理“获得”魔法。 “len”变量将设置为
字符串（这是一个宏，所以不要使用 &len）。 另请参阅“SvPVx”以获取版本
这保证只评估 sv 一次。

请注意，不能保证“SvPV()”的返回值等于
“SvPVX(sv)”，或“SvPVX(sv)”包含有效数据，或连续调用
“SvPV(sv)”每次都会返回相同的指针值。 这是由于方式
处理诸如重载和写时复制之类的事情。 在这些情况下，
返回值可能指向一个临时缓冲区或类似的。 如果你绝对需要
SvPVX 字段是否有效（例如，如果您打算写入它），请参阅
“SvPV_force”。

字符* SvPV(SV* sv, STRLEN len)

SVPV字节
与“SvPV”类似，但如有必要，首先将 sv 转换为字节表示。

字符* SvPVbyte(SV* sv, STRLEN len)

SvPV字节
与“SvPV”类似，但如有必要，首先将 sv 转换为字节表示。
保证只评估 sv 一次； 否则使用更有效的“SvPVbyte”。

字符* SvPVbytex(SV* sv, STRLEN len)

SVPVbytex_force
与“SvPV_force”类似，但如有必要，首先将 sv 转换为字节表示。
保证只评估 sv 一次； 使用更高效的“SvPVbyte_force”
除此以外。

字符* SvPVbytex_force(SV* sv, STRLEN len)

SvPVbyte_force
与“SvPV_force”类似，但如有必要，首先将 sv 转换为字节表示。

字符* SvPVbyte_force(SV* sv, STRLEN len)

SvPVbyte_nolen
与“SvPV_nolen”类似，但如有必要，首先将 sv 转换为字节表示。

字符* SvPVbyte_nolen(SV* sv)

SVPVutf8
与“SvPV”类似，但如有必要，首先将 sv 转换为 utf8。

字符* SvPVutf8(SV* sv, STRLEN len)

SVPVutf8x
与“SvPV”类似，但如有必要，首先将 sv 转换为 utf8。 保证评估
sv 只有一次； 否则使用更有效的“SvPVutf8”。

字符* SvPVutf8x(SV* sv, STRLEN len)

SvPVutf8x_force
与“SvPV_force”类似，但如有必要，首先将 sv 转换为 utf8。 保证
只评估 sv 一次； 否则使用更有效的“SvPVutf8_force”。

字符* SvPVutf8x_force(SV* sv, STRLEN len)

SvPVutf8_force
与“SvPV_force”类似，但如有必要，首先将 sv 转换为 utf8。

字符* SvPVutf8_force(SV* sv, STRLEN len)

SvPVutf8_nolen
与“SvPV_nolen”类似，但如有必要，首先将 sv 转换为 utf8。

字符* SvPVutf8_nolen(SV* sv)

SvPVX 返回一个指向 SV 中物理字符串的指针。 SV 必须包含一个字符串。
在 5.9.3 之前，执行此宏是不安全的，除非 SV 的类型 >=
SVt_PV。

这也用于在 XS AUTOLOAD 中存储自动加载的子例程的名称
常规。 请参阅 perlguts 中的“使用 XSUB 自动加载”。

字符* SvPVX(SV* sv)

SvPVx “SvPV”的一个版本，它保证只评估一次“sv”。 仅在以下情况下使用
“sv”是一个有副作用的表达式，否则使用更有效的“SvPV”。

字符* SvPVx(SV* sv, STRLEN len)

SvPV_force
类似于“SvPV”，但会强制 SV 包含一个字符串（“SvPOK”），并且只有一个
字符串（“SvPOK_only”），通过钩子或骗子。 如果你要这样做，你需要力量
直接更新“SvPVX”。 流程变得神奇。

请注意，将任意标量强制转换为普通 PV 可能会剥离
从中得到有用的数据。 例如，如果 SV 是“SvROK”，那么所指对象将
其引用计数递减，并且 SV 本身可以转换为
“SvPOK”标量，带有一个字符串缓冲区，其中包含一个值，例如“ARRAY（0x1234）”。

字符* SvPV_force(SV* sv, STRLEN len)

SvPV_force_nomg
像“SvPV_force”，但不处理变魔术。

char* SvPV_force_nomg(SV* sv, STRLEN len)

SVPV_nolen
与“SvPV”类似，但不设置长度变量。

字符* SvPV_nolen(SV* sv)

SVPV_nomg
像“SvPV”，但不处理魔法。

字符* SvPV_nomg(SV* sv, STRLEN len)

SvPV_nmg_nolen
像“SvPV_nolen”，但不处理魔法。

字符* SvPV_nomg_nolen(SV* sv)

SvPV_set
这可能不是您想要使用的，您可能想要“sv_usepvn_flags”
或“sv_setpvn”或“sv_setpvs”。

将“sv”中的 PV 指针的值设置为 Perl 分配的“NUL”-终止
字符串“val”。 另见“SvIV_set”。

请记住释放先前的 PV 缓冲区。 有很多事情要检查。 谨防
现有指针可能涉及写时复制或其他恶作剧，所以
执行“SvOOK_off(sv)”并使用“sv_force_normal”或“SvPV_force”（或检查 SvIsCOW
标志）首先确保此修改是安全的。 最后，如果它不是
COW，调用“SvPV_free”来释放先前的 PV 缓冲区。

void SvPV_set(SV* sv, char* val)

SVREFCNT
返回对象的引用计数值。

U32 SvREFCNT(SV* sv)

SvREFCNT_dec
减少给定 SV 的引用计数。 sv 可能为 NULL。

无效 SvREFCNT_dec(SV* sv)

SvREFCNT_dec_NN
与 SvREFCNT_dec 相同，但只有在您知道的情况下才能使用 sv 不为 NULL。 因为我们
不必检查 NULLness，它更快更小。

无效 SvREFCNT_dec_NN(SV* sv)

SvREFCNT_inc
增加给定 SV 的引用计数，返回 SV。

以下所有 SvREFCNT_inc* 宏都是 SvREFCNT_inc 的优化版本，
并且可以用 SvREFCNT_inc 替换。

SV* SvREFCNT_inc(SV* sv)

SvREFCNT_inc_NN
与 SvREFCNT_inc 相同，但只有在您知道的情况下才能使用 sv 不为 NULL。 因为我们
不必检查 NULLness，它更快更小。

SV* SvREFCNT_inc_NN(SV* sv)

SvREFCNT_inc_simple
与 SvREFCNT_inc 相同，但只能与没有副作用的表达式一起使用。
由于我们不必存储临时值，因此速度更快。

SV* SvREFCNT_inc_simple(SV* sv)

SvREFCNT_inc_simple_NN
与 SvREFCNT_inc_simple 相同，但只有在你知道的情况下才能使用 sv 不是 NULL。
由于我们不必检查 NULL，它更快更小。

SV* SvREFCNT_inc_simple_NN(SV* sv)

SvREFCNT_inc_simple_void
与 SvREFCNT_inc_simple 相同，但只能在不需要返回时使用
价值。 宏不需要返回有意义的值。

无效SvREFCNT_inc_simple_void（SV * sv）

SvREFCNT_inc_simple_void_NN
与 SvREFCNT_inc 相同，但只能在不需要返回值时使用，并且
你知道的 sv 不为 NULL。 宏不需要返回有意义的
值，或检查是否为 NULL，因此它更小更快。

无效SvREFCNT_inc_simple_void_NN（SV * sv）

SvREFCNT_inc_void
与 SvREFCNT_inc 相同，但只能在不需要返回值时使用。
宏不需要返回有意义的值。

无效 SvREFCNT_inc_void(SV* sv)

SvREFCNT_inc_void_NN
与 SvREFCNT_inc 相同，但只能在不需要返回值时使用，并且
你知道的 sv 不为 NULL。 宏不需要返回有意义的
值，或检查是否为 NULL，因此它更小更快。

无效 SvREFCNT_inc_void_NN(SV* sv)

SvROK 测试 SV 是否为 RV。

U32 SvROK(SV* sv)

关闭
取消设置 SV 的 RV 状态。

无效 SvROK_off(SV* sv)

SvROK_on
告诉 SV 它是 RV。

无效 SvROK_on(SV* sv)

SvRV 取消引用 RV 以返回 SV。

SV* SVRV(SV* SV)

SVRV_set
将 sv 中的 RV 指针的值设置为 val。 参见“SvIV_set”。

void SvRV_set(SV* sv, SV* val)

SvSTASH 返回 SV 的存储。

高压* SvSTASH(SV* sv)

SvSTASH_set
将 sv 中的 STASH 指针的值设置为 val。 参见“SvIV_set”。

无效 SvSTASH_set(SV* sv, HV* val)

SvTAINT 如果启用了污染，并且如果某些输入到当前表达式，则污染 SV
被污染——通常是一个变量，但也可能是隐式输入，例如语言环境
设置。 “SvTAINT”将该污染传播到表达式的输出
以悲观的方式； 即，不注意究竟是哪个
输出受哪些输入的影响。

无效 SvTAINT(SV* sv)

受宠若惊
检查 SV 是否被污染。 如果是则返回 TRUE，否则返回 FALSE。

布尔 SvTAINTED(SV* sv)

SvTAINTED_off
污染 SV。 是 非常 小心这个程序，因为它会短路一些
Perl 的基本安全特性。 XS 模块作者不应该使用这个
除非他们完全理解无条件的所有含义
不污染价值。 应该以标准的 perl 方式进行清理，通过
精心设计的正则表达式，而不是直接清除变量。

无效 SvTAINTED_off(SV* sv)

SvTAINTED_on
如果启用了污染，则将 SV 标记为已污染。

无效 SvTAINTED_on(SV* sv)

SvTRUE 返回一个布尔值，指示 Perl 是否会将 SV 评估为真或假。
参见 OK() 对于已定义/未定义的测试。 处理“获取”魔法，除非标量是
已经是 SvPOK、SvIOK 或 SvNOK（公共标志，而不是私有标志）。

布尔 SvTRUE(SV* sv)

SvTRUE_nomg
返回一个布尔值，指示 Perl 是否会将 SV 评估为真或假。
参见 OK() 对于已定义/未定义的测试。 不处理'get'魔法。

布尔 SvTRUE_nomg(SV* sv)

SvTYPE 返回 SV 的类型。 参见“svtype”。

svtype SvTYPE(SV* sv)

SvUOK 返回一个布尔值，指示 SV 是否包含一个整数，该整数必须是
解释为无符号。 一个非负整数，其值在范围内
IV 和 UV 都可以标记为 SvUOK 或 SVIOK。

布尔 SvUOK(SV* sv)

升级
用于将 SV 升级为更复杂的形式。 使用“sv_upgrade”执行
必要时升级。 参见“svtype”。

void SvUPGRADE(SV* sv, svtype 类型)

SvUTF8 返回一个 U32 值，指示 SV 的 UTF-8 状态。 如果事情已经安排好了
正确地，这表明 SV 是否包含 UTF-8 编码数据。 你
应该使用这个 after 打电话给 SVPV() 或其变体之一，以防万一
字符串重载更新内部标志。

如果要考虑字节杂注，请改用“DO_UTF8”。

U32 SvUTF8(SV* sv)

SvUTF8_关闭
取消设置 SV 的 UTF-8 状态（数据没有改变，只是标志）。 不要
轻率地使用。

无效 SvUTF8_off(SV *sv)

SvUTF8_on
打开一个 SV 的 UTF-8 状态（数据没有改变，只是标志）。 做
不要轻率地使用。

无效 SvUTF8_on(SV *sv)

SvUV 将给定的 SV 强制为一个无符号整数并返回它。 参见“SvUVx”
保证只评估 sv 一次的版本。

紫外线 SvUV(SV* sv)

SvUVX 返回 SV 的 UV 槽中的原始值，不进行检查或转换。 仅有的
当您确定 SvIOK 为真时使用。 另见“SvUV()”。

紫外线 SvUVX(SV* sv)

SvUVx 将给定的 SV 强制为一个无符号整数并返回它。 保证
只评估一次“sv”。 仅当“sv”是带有边的表达式时才使用
效果，否则使用更有效的“SvUV”。

紫外线 SvUVx(SV* sv)

SVUV_nomg
像“SvUV”，但不处理魔法。

紫外线 SvUV_nomg(SV* sv)

SVUV_set
将sv中UV指针的值设置为val。 参见“SvIV_set”。

void SvUV_set(SV* sv, UV val)

SvVOK 返回一个布尔值，指示 SV 是否包含 v-string。

布尔 SvVOK(SV* sv)

sv_catpvn_nomg
像“sv_catpvn”，但不处理魔法。

void sv_catpvn_nomg(SV* sv, const char* ptr,
斯特伦）

sv_catpv_nomg
像 "sv_catpv" 但不处理魔法。

无效 sv_catpv_nomg(SV* sv, const char* ptr)

sv_catsv_nomg
像 "sv_catsv" 但不处理魔法。

无效 sv_catsv_nomg（SV* dsv，SV* ssv）

sv_衍生_from
与“sv_derived_from_pv”完全一样，但不采用“flags”参数。

bool sv_derived_from(SV* sv, const char *const 名称)

sv_衍生_from_pv
与 "sv_derived_from_pvn" 完全一样，但采用以 nul 结尾的字符串而不是
字符串/长度对。

布尔 sv_derived_from_pv(SV* sv,
const char *const 名称，
U32 标志）

sv_衍生_from_pvn
返回一个布尔值，指示 SV 是否派生自指定的类 at
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 C 水平. 要在 Perl 级别检查派生，请像普通 Perl 一样调用“isa()”
方法。

目前，“标志”的唯一重要值是 SVf_UTF8。

布尔 sv_derived_from_pvn(SV* sv,
const char *const 名称，
const STRLEN len，U32 标志）

sv_衍生自_sv
与“sv_derived_from_pvn”完全一样，但采用 SV 形式的名称字符串
而不是字符串/长度对。

bool sv_衍生_from_sv(SV* sv, SV *namesv,
U32 标志）

sv_does 与“sv_does_pv”类似，但不采用“flags”参数。

bool sv_does(SV* sv, const char *const 名称)

sv_does_pv
与“sv_does_sv”类似，但采用以 nul 结尾的字符串而不是 SV。

bool sv_does_pv(SV* sv, const char *const 名称,
U32 标志）

sv_does_pvn
与“sv_does_sv”类似，但采用字符串/长度对而不是 SV。

bool sv_does_pvn(SV* sv, const char *const 名称,
const STRLEN len，U32 标志）

sv_does_sv
返回一个布尔值，指示 SV 是否执行特定的命名角色。 这
SV 可以是 Perl 对象或 Perl 类的名称。

bool sv_does_sv(SV* sv, SV* namesv, U32 标志)

sv_report_used
转储所有尚未释放的 SV 的内容（调试辅助）。

无效 sv_report_used()

sv_setsv_nomg
像 "sv_setsv" 但不处理魔法。

无效 sv_setsv_nomg（SV* dsv，SV* ssv）

sv_utf8_upgrade_nomg
像 sv_utf8_upgrade，但不会对“sv”施展魔法。

STRLEN sv_utf8_upgrade_nomg(NN SV *sv)

SV-身体 分配

看起来像个数
测试 SV 的内容是否看起来像一个数字（或者是一个数字）。 “信息”和
“无穷大”被视为数字（因此不会发出非数字警告），即使
如果你的 阿托夫（） 不了解他们。 Get-magic 被忽略。

I32 看起来像数字（SV *const sv）

新RV_noinc
为 SV 创建 RV 包装器。 原始 SV 的引用计数是 而不去
增加了。

SV* newRV_noinc(SV *const tmpRef)

newSV 创建一个新的 SV。 一个非零的“len”参数表示的字节数
SV 应具有的预分配字符串空间。 尾随“NUL”的额外字节
也是保留的。 （即使是字符串空间，也没有为 SV 设置 SvPOK
已分配。）新 SV 的引用计数设置为 1。

5.9.3年， 新SV() 取代旧的 新闻SV() API，并删除第一个参数，
x，一种调试辅助工具，允许调用者识别自己。 该援助已
被一个新的构建选项 PERL_MEM_LOG 取代（参见“PERL_MEM_LOG”
提示）。 旧的 API 仍然可以在 XS 模块中使用，支持
较旧的 perls。

SV* newSV(const STRLEN len)

新SVhek
从散列键结构创建一个新的 SV。 它将生成该点的标量
尽可能到共享字符串表。 返回一个新的（未定义的）SV，如果
hek 为 NULL。

SV* newSVhek(const HEK *const hek)

newSViv 创建一个新的 SV 并将一个整数复制到其中。 SV 的引用计数是
设置为1。

SV* newSViv(const IV i)

newSVnv 创建一个新的 SV 并将一个浮点值复制到其中。 参考计数
SV 设置为 1。

SV* newSVnv(常量 NV n)

newSVpv 创建一个新的 SV 并复制一个字符串（可能包含“NUL”（“\0”）字符）
进去。 SV 的引用计数设置为 1。如果“len”为零，Perl 将
使用计算长度 字符串（）, （这意味着如果您使用此选项，则“s”
不能嵌入“NUL”字符并且必须有一个终止“NUL”字节）。

为了提高效率，请考虑改用“newSVpvn”。

SV* newSVpv(const char *const s, const STRLEN len)

新SVpvf
创建一个新的 SV 并使用“sprintf”格式的字符串对其进行初始化。

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

新SVpvn
创建一个新的 SV 并将一个字符串复制到其中，其中可能包含“NUL”字符
("\0") 和其他二进制数据。 SV 的引用计数设置为 1。 注意
如果 "len" 为零，Perl 将创建一个零长度 (Perl) 字符串。 你是
负责确保源缓冲区的长度至少为“len”字节。 如果
“buffer”参数为 NULL，新的 SV 将是未定义的。

SV* newSVpvn(const char *const s, const STRLEN len)

新SVpvn_flags
创建一个新的 SV 并复制一个字符串（可能包含“NUL”（“\0”）字符）
进去。 SV 的引用计数设置为 1。请注意，如果“len”为零，
Perl 将创建一个零长度的字符串。 您有责任确保
源字符串的长度至少为“len”字节。 如果“s”参数为 NULL，则新的
SV 将是未定义的。 目前唯一接受的标志位是“SVf_UTF8”和
“SVs_TEMP”。 如果设置了“SVs_TEMP”，则在结果上调用“sv_2mortal()”
在返回之前。 如果设置了“SVf_UTF8”，则“s”被认为是 UTF-8，并且
“SVf_UTF8”标志将设置在新的 SV 上。 “newSVpvn_utf8()”很方便
此函数的包装器，定义为

#define newSVpvn_utf8(s, len, u) \
newSVpvn_flags（（s），（len），（u）？SVf_UTF8：0）

SV* newSVpvn_flags(const char *const s,
const STRLEN 长度，
const U32 标志）

newSVpvn_share
创建一个新的 SV，其 SvPVX_const 指向字符串中的共享字符串
桌子。 如果表中尚不存在该字符串，则首先创建该字符串。
打开 SvIsCOW 标志（或 5.16 及更早版本中的 READONLY 和 FAKE）。 如果
“hash”参数非零，使用该值； 否则计算哈希。
稍后可以使用“SvSHARED_HASH()”从 SV 中检索字符串的哈希值
宏。 这里的想法是字符串表用于共享哈希键
这些字符串将具有 SvPVX_const == HeKEY 并且哈希查找将避免字符串
比较。

SV* newSVpvn_share(const char* s, I32 len, U32 哈希)

新SVpvs
与“newSVpvn”类似，但采用文字“NUL”结尾的字符串而不是
字符串/长度对。

SV* newSVpvs(const char* s)

新SVpvs_flags
与“newSVpvn_flags”类似，但采用文字“NUL”结尾的字符串而不是
字符串/长度对。

SV* newSVpvs_flags（const char* s，U32 标志）

newSVpvs_share
与“newSVpvn_share”类似，但采用文字“NUL”结尾的字符串而不是
字符串/长度对并省略散列参数。

SV* newSVpvs_share(const char* s)

newSVpv_share
与“newSVpvn_share”类似，但采用“NUL”结尾的字符串而不是
字符串/长度对。

SV* newSVpv_share(const char* s, U32 哈希)

newSVrv 为现有的 RV 创建一个新的 SV，“rv”，以指向。 如果“rv”不是 RV
然后它将升级为一个。 如果“classname”不为空，那么新的 SV 将
在指定的包裹中得到祝福。 返回新的 SV 及其引用
count 为 1。引用计数 1 归“rv”所有。

SV* newSVrv(SV *const rv,
const char *const 类名）

newSVsv 创建一个与原始 SV 完全相同的新 SV。 （使用
“sv_setsv”。）

SV* newSVsv(SV *const old)

newSVuv 创建一个新的 SV 并将一个无符号整数复制到其中。 参考计数
SV 设置为 1。

SV* newSVuv(常量 UV u)

新SV_type
创建指定类型的新 SV。 新 SV 的引用计数为
设置为1。

SV* newSV_type(const svtype 类型)

sv_2布尔
此宏仅供 sv_true() 或其宏等价物，并且仅当
后者的论点既不是 SvPOK、SvIOK 也不是 SvNOK。 它调用 sv_2bool_flags
SV_GMAGIC 标志。

布尔 sv_2bool(SV *const sv)

sv_2bool_flags
此功能仅供 sv_true() 和朋友，而且只有后者的
参数既不是 SvPOK、SvIOK 也不是 SvNOK。 如果标志包含 SV_GMAGIC，则
它做了一个 mg_get() 第一。

bool sv_2bool_flags(SV *sv, I32 标志)

sv_2cv 使用各种策略，尝试从 SV 中获取 CV； 此外，尽可能尝试
将 *st 和 *gvp 设置为与其关联的 stash 和 GV。 “lref”中的标志是
传递给 gv_fetchsv。

CV* sv_2cv(SV* sv, HV **const st, GV **const gvp,
常量 I32 lref)

sv_2io 使用各种策略，尝试从 SV 获取 IO：如果是 GV，则为 IO 插槽； 或者
如果我们是 RV，则递归结果； 或以
PV 如果我们是一个字符串。

'Get' 魔法在传入的 sv 上被忽略，但如果 sv 将在“SvRV(sv)”上调用
是房车。

IO* sv_2io(SV *const sv)

sv_2iv_flags
返回 SV 的整数值，进行任何必要的字符串转换。 如果
flags 包括 SV_GMAGIC，做一个 mg_get() 第一的。 通常通过
“SvIV(sv)”和“SvIVx(sv)”宏。

IV sv_2iv_flags(SV *const sv, const I32 标志)

sv_2凡人
将现有的 SV 标记为 mortal。 SV 将“很快”被销毁，或者被
对 FREETMPS 的显式调用，或在语句等位置进行隐式调用
边界。 温度() 开启这意味着SV的字符串缓冲区可以
如果此 SV 被复制，则“被盗”。 另见“sv_newmortal”和“sv_mortalcopy”。

SV* sv_2mortal(SV *const sv)

sv_2nv_flags
返回 SV 的 num 值，进行任何必要的字符串或整数转换。
如果 flags 包含 SV_GMAGIC，是否 mg_get() 第一的。 通常通过
“SvNV(sv)”和“SvNVx(sv)”宏。

NV sv_2nv_flags(SV *const sv, const I32 标志)

sv_2pv字节
返回指向 SV 的字节编码表示的指针，并将 *lp 设置为其
长度。 作为副作用，可能会导致 SV 从 UTF-8 降级。

通常通过“SvPVbyte”宏访问。

char* sv_2pvbyte(SV *sv, STRLEN *const lp)

sv_2pvutf8
返回指向 SV 的 UTF-8 编码表示的指针，并将 *lp 设置为其
长度。 作为副作用，可能会导致 SV 升级到 UTF-8。

通常通过“SvPVutf8”宏访问。

char* sv_2pvutf8(SV *sv, STRLEN *const lp)

sv_2pv_flags
返回指向 SV 字符串值的指针，并将 *lp 设置为其长度。 如果
flags 包括 SV_GMAGIC，做一个 mg_get() 第一的。 强制 sv 到一个字符串 if
必要的。 通常通过“SvPV_flags”宏调用。 “sv_2pv()”和
“sv_2pv_nomg”通常也会在这里结束。

char* sv_2pv_flags（SV *const sv，STRLEN *const lp，
const I32 标志）

sv_2uv_flags
返回 SV 的无符号整数值，进行任何必要的字符串转换。
如果 flags 包含 SV_GMAGIC，是否 mg_get() 第一的。 通常通过
“SvUV(sv)”和“SvUVx(sv)”宏。

UV sv_2uv_flags(SV *const sv, const I32 标志)

sv_退避
删除任何字符串偏移量。 您通常应该使用“SvOOK_off”宏包装器
代替。

int sv_backoff(SV *const sv)

sv_bless
将 SV 祝福到指定的包裹中。 SV 必须是 RV。 包必须
由其存储指定（参见“gv_stashpv()”）。 SV 的引用计数为
不受影响。

SV* sv_bless(SV *const sv, HV *const stash)

sv_catpv
将“NUL”终止的字符串连接到字符串的末尾
SV。 如果 SV 设置了 UTF-8 状态，那么附加的字节应该是
有效的 UTF-8。 处理“get”魔法，但不处理“set”魔法。 参见“sv_catpv_mg”。

void sv_catpv(SV *const sv, const char* ptr)

sv_catpvf
处理其参数，如“sprintf”，并将格式化的输出附加到 SV。
如果附加数据包含“宽”字符（包括但不限于，
具有 UTF-8 PV 格式为 %s 且字符 >255 格式为 %c 的 SV），
原始 SV 可能会升级到 UTF-8。 处理“get”魔法，但不处理“set”
魔法。 参见“sv_catpvf_mg”。 如果原始 SV 是 UTF-8，则模式应该是
有效的 UTF-8； 如果原始 SV 是字节，则模式也应该是。

void sv_catpvf(SV *const sv, const char *const pat,
...）

sv_catpvf_mg
像 "sv_catpvf"，但也处理 'set' 魔法。

无效 sv_catpvf_mg(SV *const sv,
const char *const pat，...）

sv_catpvn
将字符串连接到 SV 中字符串的末尾。 “伦”
表示要复制的字节数。 如果 SV 设置了 UTF-8 状态，则
附加的字节应该是有效的 UTF-8。 处理“get”魔法，但不处理“set”魔法。
参见“sv_catpvn_mg”。

void sv_catpvn(SV *dsv, const char *sstr, STRLEN len)

sv_catpvn_flags
将字符串连接到 SV 中字符串的末尾。 “伦”
表示要复制的字节数。

默认情况下，如果 SV 有
UTF-8 状态集，否则为一串字节。 可以强制附加
通过提供“SV_CATUTF8”标志将字符串解释为 UTF-8，并作为字节
通过提供“SV_CATBYTES”标志； SV 或附加的字符串将是
必要时升级到 UTF-8。

如果 "flags" 设置了 "SV_SMAGIC" 位，之后将在 "dsv" 上设置 "mg_set" 如果
合适的。 “sv_catpvn”和“sv_catpvn_nomg”就是按照这个来实现的
功能。

无效 sv_catpvn_flags(SV *const dstr,
常量字符 *sstr,
const STRLEN 长度，
const I32 标志）

sv_catpvs
与“sv_catpvn”类似，但采用文字字符串而不是字符串/长度对。

void sv_catpvs(SV* sv, const char* s)

sv_catpvs_flags
与“sv_catpvn_flags”类似，但采用文字“NUL”结尾的字符串而不是
字符串/长度对。

void sv_catpvs_flags(SV* sv, const char* s,
I32 标志）

sv_catpvs_mg
与“sv_catpvn_mg”类似，但采用文字字符串而不是字符串/长度对。

void sv_catpvs_mg(SV* sv, const char* s)

sv_catpvs_nomg
与“sv_catpvn_nomg”类似，但采用文字字符串而不是字符串/长度对。

无效 sv_catpvs_nomg(SV* sv, const char* s)

sv_catpv_flags
将“NUL”终止的字符串连接到字符串的末尾
SV。 如果 SV 设置了 UTF-8 状态，那么附加的字节应该是
有效的 UTF-8。 如果“flags”设置了“SV_SMAGIC”位，则“mg_set”会在
适当时修改 SV。

void sv_catpv_flags(SV *dstr, const char *sstr,
const I32 标志）

sv_catpv_mg
像 "sv_catpv"，但也处理 'set' 魔法。

void sv_catpv_mg(SV *const sv, const char *const ptr)

sv_catsv
将 SV "ssv" 中的字符串连接到 SV "dsv" 中字符串的末尾。 如果
“ssv”为空，什么都不做； 否则仅修改“dsv”。 处理“获得”魔法
在两个 SV 上，但没有“设置”魔法。 参见“sv_catsv_mg”和“sv_catsv_nomg”。

无效 sv_catsv(SV *dstr, SV *sstr)

sv_catsv_flags
将 SV "ssv" 中的字符串连接到 SV "dsv" 中字符串的末尾。 如果
“ssv”为空，什么都不做； 否则仅修改“dsv”。 如果“标志”包括
“SV_GMAGIC”位设置，如果合适，将在两个 SV 上调用“mg_get”。 如果“旗帜”
include "SV_SMAGIC", "mg_set" 将在修改后的 SV 上调用，如果
合适的。 “sv_catsv”、“sv_catsv_nomg”和“sv_catsv_mg”在
这个功能的条款。

无效 sv_catsv_flags(SV *const dsv, SV *const ssv,
const I32 标志）

sv_chop 从字符串缓冲区的开头高效删除字符。
SvPOK(sv) 或至少 SvPOKp(sv) 必须为真，并且“ptr”必须是指向
字符串缓冲区内的某处。 “ptr”成为第一个字符
调整字符串。 使用“OOK hack”。 返回时，只有 SvPOK(sv) 和 SvPOKp(sv)
OK 标志之间将为真。

注意：此函数返回后，“ptr”和 SvPVX_const(sv) 可能不再引用
到同一块数据。

不幸的是，这个函数的名字与 Perl 的“chop”相似
运算符纯属巧合。 此功能从左侧开始； “劈”
从右边工作。

void sv_chop(SV *const sv, const char *const ptr)

sv_清除
清除 SV：调用任何析构函数，释放主体使用的任何内存，然后释放
身体本身。 SV的头是 而不去 已释放，尽管它​​的类型设置为全 1
以免在全球破坏期间不经意间假定它是活的
等等。这个函数应该只在 REFCNT 为零时调用。 大多数时候
您需要调用“sv_free()”（或其宏包装器“SvREFCNT_dec”）。

无效 sv_clear(SV *const orig_sv)

sv_cmp 比较两个 SV 中的字符串。 返回 -1、0 或 1，指示是否
“sv1”中的字符串小于、等于或大于“sv2”中的字符串。 是
UTF-8 和“使用字节”感知，句柄变得神奇，并将强制其参数
必要时使用字符串。 另见“sv_cmp_locale”。

I32 sv_cmp(SV *const sv1, SV *const sv2)

sv_cmp_flags
比较两个 SV 中的字符串。 返回 -1、0 或 1，指示是否
“sv1”中的字符串小于、等于或大于“sv2”中的字符串。 是
UTF-8 和“使用字节”感知并在必要时将其 args 强制转换为字符串。 如果
标志包括 SV_GMAGIC，它处理 get magic。 也可以看看
“sv_cmp_locale_flags”。

I32 sv_cmp_flags(SV *const sv1, SV *const sv2,
const U32 标志）

sv_cmp_区域设置
以区域设置感知方式比较两个 SV 中的字符串。 是 UTF-8 和 '使用
字节知道，句柄会变魔术，并且会在必要时将其 args 强制转换为字符串。
另见“sv_cmp”。

I32 sv_cmp_locale(SV *const sv1, SV *const sv2)

sv_cmp_locale_flags
以区域设置感知方式比较两个 SV 中的字符串。 是 UTF-8 和 '使用
bytes' 知道并会在必要时将其 args 强制转换为字符串。 如果旗帜
包含 SV_GMAGIC，它处理获取魔法。 另见“sv_cmp_flags”。

I32 sv_cmp_locale_flags(SV *const sv1,
SV *常量 sv2,
const U32 标志）

sv_collxfrm
这将调用带有 SV_GMAGIC 标志的“sv_collxfrm_flags”。 请参阅“sv_collxfrm_flags”。

char* sv_collxfrm（SV *const sv，STRLEN *const nxp）

sv_collxfrm_flags
将 Collat​​e Transform 魔法添加到 SV（如果它还没有）。 如果旗帜
包含 SV_GMAGIC，它处理 get-magic。

任何标量变量都可以携带包含标量的 PERL_MAGIC_collxfrm 魔法
变量的数据，但转换为普通内存的格式
比较可用于根据区域设置比较数据。

char* sv_collxfrm_flags(SV *const sv,
STRLEN *const nxp,
I32 常量标志）

sv_copypv_flags
sv_copypv 和 sv_copypv_nomg 的实现。 如果标志包括
SV_GMAGIC。

无效 sv_copypv_flags(SV *const dsv, SV *const ssv,
const I32 标志）

sv_copypv_nomg
与 sv_copypv 类似，但不会先调用 get magic。

无效 sv_copypv_nomg(SV *const dsv, SV *const ssv)

sv_dec 自动递减 SV 中的值，如果是，则进行字符串到数字的转换
必要的。 处理“获取”魔法和运算符重载。

无效 sv_dec(SV *const sv)

sv_dec_nomg
自动递减 SV 中的值，如果是，则进行字符串到数字的转换
必要的。 处理运算符重载。 跳过处理“get”魔法。

无效 sv_dec_nomg(SV *const sv)

sv_eq 返回一个布尔值，指示两个 SV 中的字符串是否相同。 是
UTF-8 和“使用字节”感知，句柄变得神奇，并将强制其参数
必要时使用字符串。

I32 sv_eq(SV* sv1, SV* sv2)

sv_eq_flags
返回一个布尔值，指示两个 SV 中的字符串是否相同。 是
UTF-8 和“使用字节”感知并在必要时将其 args 强制为字符串。 如果
标志包括 SV_GMAGIC，它也处理 get-magic。

I32 sv_eq_flags(SV* sv1, SV* sv2, const U32 标志)

sv_force_normal_flags
在 SV 上撤消各种类型的伪造，其中伪造的意思是“超过”一个字符串：如果
PV 是共享字符串，制作一个私有副本； 如果我们是裁判，请停止裁判； 如果
我们是一个 glob，降级为 xpvmg； 如果我们是一个写时复制标量，这就是
我们进行复制时的 on-write 时间，并且也在本地使用； 如果这是一个 vstring，
放弃 vstring 魔法。 如果设置了“SV_COW_DROP_PV”，则为写时复制标量
删除其 PV 缓冲区（如果有）并变为 SvPOK_off 而不是制作副本。
（用于该标量即将设置为其他值的情况。）此外，
取消引用时，“flags”参数被传递给“sv_unref_flags()”。
“sv_force_normal” 调用此函数并将标志设置为 0。

该函数预计将用于向 perl 发出该 SV 即将被发送的信号
写，任何额外的簿记都需要处理。 因此，它
对只读值嗤之以鼻。

无效 sv_force_normal_flags(SV *const sv,
const U32 标志）

sv_free 减少一个 SV 的引用计数，如果它下降到零，调用“sv_clear”
调用析构函数并释放主体使用的任何内存； 最后，解除分配
SV 的头部本身。 通常通过包装宏“SvREFCNT_dec”调用。

无效 sv_free(SV *const sv)

sv_gets 从文件句柄中获取一行并将其存储到 SV 中，可选择附加到
当前存储的字符串。 如果 "append" 不为 0，则将该行附加到 SV
而不是覆盖它。 “追加”应设置为字节偏移量
附加的字符串应该从 SV 开始（通常，“SvCUR(sv)”是一个合适的
选择）。

char* sv_gets(SV *const sv, PerlIO *const fp,
I32 附加）

sv_get_backrefs
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

如果 sv 是弱引用的目标，则它返回反向引用
与 sv 相关的结构； 否则返回 NULL。

返回非空结果时，返回的类型是相关的。 如果它是一个
AV 那么 AV 的元素是指向这个的弱参考 RV
物品。 如果它是任何其他类型，则项目本身就是弱引用。

参见 Perl_sv_add_backref(), perl_sv_del_backref(), Perl_sv_kill_backrefs()

SV* sv_get_backrefs(SV *const sv)

sv_grow 扩展 SV 中的字符缓冲区。 如有必要，使用“sv_unref”和
将 SV 升级为“SVt_PV”。 返回指向字符缓冲区的指针。 使用
“SvGROW”包装器。

char* sv_grow(SV *const sv, STRLEN newlen)

sv_inc 自动递增 SV 中的值，如果是，则进行字符串到数字的转换
必要的。 处理“获取”魔法和运算符重载。

无效 sv_inc(SV *const sv)

sv_inc_nomg
SV 中值的自动递增，如果是，则将字符串转换为数字
必要的。 处理运算符重载。 跳过处理“get”魔法。

无效 sv_inc_nomg(SV *const sv)

sv_插入
在 SV 中以指定的偏移量/长度插入字符串。 类似于
Perl的 子字符串() 功能。 手柄会变魔术。

void sv_insert(SV *const bigstr, const STRLEN 偏移量,
const STRLEN 长度，
const char *const 小，
常量 STRLEN littlelen)

sv_插入_标志
与“sv_insert”相同，但额外的“标志”被传递给“SvPV_force_flags”
这适用于“bigstr”。

无效 sv_insert_flags(SV *const bigstr,
const STRLEN 偏移量，
const STRLEN 长度，
const char *const 小，
常量 STRLEN littlelen，
const U32 标志）

sv_isa 返回一个布尔值，指示 SV 是否被祝福到指定的类。
这不检查子类型； 使用“sv_derived_from”来验证继承
关系。

int sv_isa(SV* sv, const char *const 名称)

sv_isobject
返回一个布尔值，指示 SV 是否是指向受祝福对象的 RV。
如果 SV 不是 RV，或者对象没有被祝福，那么这将返回
假。

int sv_isobject(SV* sv)

sv_len 返回 SV 中字符串的长度。 处理魔法和类型强制
适当地设置 UTF8 标志。 另请参阅“SvCUR”，它提供对
xpv_cur 插槽。

STRLEN sv_len(SV *const sv)

sv_len_utf8
返回 SV 中字符串中的字符数，计算宽 UTF-8 字节
作为单个字符。 处理魔法和类型强制。

STRLEN sv_len_utf8(SV *const sv)

sv_magic
为 SV 添加魔法。 如有必要，首先将“sv”升级为“SVt_PVMG”，然后
将“如何”类型的新魔法项目添加到魔法列表的头部。

有关处理的描述，请参见“sv_magicext”（“sv_magic”现在调用）
“名称”和“namlen”参数。

您需要使用“sv_magicext”为 SvREADONLY SV 添加魔法并添加更多
而不是相同“如何”的一个实例。

void sv_magic(SV *const sv, SV *const obj,
const int 如何，const char *const 名称，
常量 I32 名称）

sv_magicext
为 SV 添加魔法，必要时升级它。 应用提供的 vtable 和
返回一个指向添加的魔法的指针。

请注意，“sv_magicext”将允许“sv_magic”不允许的事情。 在
特别是，您可以为 SvREADONLY SV 添加魔法，并添加多个实例
同样的“如何”。

如果“namlen”大于零，则为“savepvn” 复制 “名称”的存储，如果
“namlen”为零，则“name”按原样存储，并且 - 作为另一种特殊情况 - 如果
"(name && namlen == HEf_SVKEY)" 然后 "name" 被假定包含一个 "SV*" 并且是
按原样存储，其 REFCNT 递增。

（这现在被“sv_magic”用作子程序。）

MAGIC * sv_magicext(SV *const sv, SV *const obj,
const int 如何，
常量 MGVTBL *常量 vtbl,
const char *const 名称，
常量 I32 名称）

sv_mortalcopy
创建一个新的 SV，它是原始 SV 的副本（使用“sv_setsv”）。 新的
SV被标记为凡人。 它将通过显式调用“很快”被销毁
到 FREETMPS，或在语句边界等位置进行隐式调用。 看
还有“sv_newmortal”和“sv_2mortal”。

SV* sv_mortalcopy(SV *const oldsv)

sv_newmortal
创建一个新的空 SV，它是致命的。 SV 的引用计数设置为 1。
它将“很快”被销毁，要么通过显式调用 FREETMPS，要么通过
在语句边界等地方隐式调用。 另见“sv_mortalcopy”
和“sv_2mortal”。

SV* sv_newmortal()

sv_newref
增加 SV 的引用计数。 请改用“SvREFCNT_inc()”包装器。

SV* sv_newref(SV *const sv)

sv_pos_b2u
将 offsetp 指向的值从开始的字节数转换为
字符串，计数为等效数量的 UTF-8 字符。 处理魔法和
类型强制。

优先使用“sv_pos_b2u_flags”，它可以正确处理长于
2Gb。

void sv_pos_b2u(SV *const sv, I32 *const offsetp)

sv_pos_b2u_flags
将偏移量从字符串开头的字节数转换为计数
等效数量的 UTF-8 字符。 处理类型强制。 标志 通过
到“SvPV_flags”，通常应该是“SV_GMAGIC|SV_CONST_RETURN”来处理
魔力。

STRLEN sv_pos_b2u_flags(SV *const sv,
STRLEN 常量偏移量，U32 标志）

sv_pos_u2b
将 offsetp 指向的值从 UTF-8 字符数转换为
字符串的开头，到等效字节数的计数； 如果 lenp 是非
零，它对 lenp 做同样的事情，但这次从偏移量开始，而不是
比从字符串的开头。 处理魔法和类型强制。

优先使用“sv_pos_u2b_flags”，它可以正确处理长于
2Gb。

void sv_pos_u2b(SV *const sv, I32 *const offsetp,
I32 *常量 lenp)

sv_pos_u2b_flags
将偏移量从字符串开头的 UTF-8 字符计数转换为
等效字节数； 如果 lenp 非零，它对
lenp，但这次是从偏移量开始，而不是从
细绳。 处理类型强制。 标志 传递给“SvPV_flags”，通常
应该是“SV_GMAGIC|SV_CONST_RETURN”来处理魔法。

STRLEN sv_pos_u2b_flags(SV *const sv,STRLEN uoffset,
STRLEN *const lenp，U32 标志）

sv_pvbyten_force
“SvPVbytex_force”宏的后端。 始终使用宏。

char* sv_pvbyten_force(SV *const sv, STRLEN *const lp)

sv_pvn_force
以某种方式从 SV 中获取一个合理的字符串。 的私有实现
“SvPV_force”宏，用于无法处理复杂宏表达式的编译器。
始终使用宏。

字符* sv_pvn_force(SV* sv, STRLEN* lp)

sv_pvn_force_flags
以某种方式从 SV 中获取一个合理的字符串。 如果 "flags" 设置了 "SV_GMAGIC" 位，
如果合适，将在“sv”上“mg_get”，否则不会。 “sv_pvn_force”和
“sv_pvn_force_nomg”是根据这个函数实现的。 你通常想要
改为使用各种包装宏：请参阅“SvPV_force”和“SvPV_force_nomg”

char* sv_pvn_force_flags(SV *const sv,
STRLEN *const lp,
const I32 标志）

sv_pvutf8n_force
“SvPVutf8x_force”宏的后端。 始终使用宏。

char* sv_pvutf8n_force（SV *const sv，STRLEN *const lp）

sv_reftype
返回描述 SV 引用的字符串。

const char* sv_reftype(const SV *const sv, const int ob)

sv_替换
使第一个参数成为第二个参数的副本，然后删除原始参数。 这
目标 SV 在物理上接管源 SV 主体的所有权，并且
继承它的标志； 然而，目标会保留它拥有的任何魔法，以及任何魔法
源被丢弃。 请注意，这是一个相当专业的 SV 复制
手术; 大多数时候，您会想要使用“sv_setsv”或其众多宏之一
前端。

无效 sv_replace(SV *const sv, SV *const nsv)

sv_重置
“reset” Perl 函数的底层实现。 注意 perl 级别
功能被模糊地弃用。

void sv_reset(const char* s, HV *const stash)

sv_rvweaken
弱化引用：在此 RV 上设置“SvWEAKREF”标志； 给出提到的 SV
"PERL_MAGIC_backref" 魔法，如果还没有的话； 并推送对此的反向引用
RV 到与该魔法相关的反向引用数组上。 如果房车是
魔法，清除 RV 后会调用设置魔法。

SV* sv_rvweaken(SV *const sv)

sv_setiv
将一个整数复制到给定的 SV 中，如有必要，首先升级。 才不是
处理“设置”魔法。 另见“sv_setiv_mg”。

void sv_setiv(SV *const sv, const IV num)

sv_setiv_mg
像 "sv_setiv"，但也处理 'set' 魔法。

void sv_setiv_mg(SV *const sv, const IV i)

sv_setnv
将 double 复制到给定的 SV 中，如有必要，首先升级。 不处理
'设置'魔法。 另见“sv_setnv_mg”。

void sv_setnv(SV *const sv, const NV num)

sv_setnv_mg
像 "sv_setnv"，但也处理 'set' 魔法。

void sv_setnv_mg(SV *const sv, const NV num)

sv_setpv
将字符串复制到 SV 中。 字符串必须以“NUL”字符结尾。
不处理“设置”魔法。 参见“sv_setpv_mg”。

void sv_setpv(SV *const sv, const char *const ptr)

sv_setpvf
像“sv_catpvf”一样工作，但将文本复制到 SV 中而不是附加它。
不处理“设置”魔法。 参见“sv_setpvf_mg”。

void sv_setpvf(SV *const sv, const char *const pat,
...）

sv_setpvf_mg
像 "sv_setpvf"，但也处理 'set' 魔法。

无效 sv_setpvf_mg(SV *const sv,
const char *const pat，...）

sv_setpviv
将整数复制到给定的 SV 中，同时更新其字符串值。 才不是
处理“设置”魔法。 参见“sv_setpviv_mg”。

void sv_setpviv(SV *const sv, const IV num)

sv_setpviv_mg
像“sv_setpviv”，但也处理“设置”魔法。

void sv_setpviv_mg(SV *const sv, const IV iv)

sv_setpvn
将字符串（可能包含嵌入的“NUL”字符）复制到 SV。 这
“len”参数表示要复制的字节数。 如果“ptr”参数
为 NULL 时，SV 将变为未定义。 不处理“设置”魔法。 看
“sv_setpvn_mg”。

void sv_setpvn(SV *const sv, const char *const ptr,
const STRLEN 长度）

sv_setpvn_mg
像 "sv_setpvn"，但也处理 'set' 魔法。

无效 sv_setpvn_mg(SV *const sv,
常量 char *常量 ptr，
const STRLEN 长度）

sv_setpvs
与“sv_setpvn”类似，但采用文字字符串而不是字符串/长度对。

void sv_setpvs(SV* sv, const char* s)

sv_setpvs_mg
与“sv_setpvn_mg”类似，但采用文字字符串而不是字符串/长度对。

void sv_setpvs_mg(SV* sv, const char* s)

sv_setpv_mg
像“sv_setpv”，但也处理“设置”魔法。

void sv_setpv_mg(SV *const sv, const char *const ptr)

sv_setref_iv
将整数复制到新的 SV 中，可选择祝福 SV。 “rv”参数
将升级为房车。 该 RV 将被修改为指向新的 SV。 这
“classname”参数表示祝福的包。 将“类名”设置为
“NULL”避免祝福。 新 SV 的引用计数为 1，并且
房车将被退回。

SV* sv_setref_iv(SV *const rv,
const char *const 类名，
常量 IV iv)

sv_setref_nv
将双倍复制到新的 SV 中，可选择祝福 SV。 “rv”参数将
升级为房车。 该 RV 将被修改为指向新的 SV。 这
“classname”参数表示祝福的包。 将“类名”设置为
“NULL”避免祝福。 新 SV 的引用计数为 1，并且
房车将被退回。

SV* sv_setref_nv(SV *const rv,
const char *const 类名，
常量 NV nv)

sv_setref_pv
将指针复制到新的 SV 中，可选择祝福 SV。 “rv”参数
将升级为房车。 该 RV 将被修改为指向新的 SV。 如果
“pv”参数为 NULL，然后“PL_sv_undef”将被放入 SV。 这
“classname”参数表示祝福的包。 将“类名”设置为
“NULL”避免祝福。 新 SV 的引用计数为 1，并且
房车将被退回。

不要与其他 Perl 类型如 HV、AV、SV、CV 一起使用，因为这些对象
将被指针复制过程损坏。

请注意，“sv_setref_pvn”复制字符串，而这复制指针。

SV* sv_setref_pv(SV *const rv,
const char *const 类名，
无效*常量 pv)

sv_setref_pvn
将字符串复制到新的 SV 中，可选择祝福 SV。 的长度
字符串必须用“n”指定。 “rv”参数将升级为 RV。
该 RV 将被修改为指向新的 SV。 “类名”参数
表示祝福的包裹。 将“classname”设置为“NULL”以避免
祝福。 新 SV 的引用计数为 1，RV 为
回。

请注意，“sv_setref_pv”复制指针，而这复制字符串。

SV* sv_setref_pvn(SV *const rv,
const char *const 类名，
常量字符 *常量 pv,
常量STRLEN n)

sv_setref_pvs
与“sv_setref_pvn”类似，但采用文字字符串而不是字符串/长度对。

SV * sv_setref_pvs(const char* s)

sv_setref_uv
将无符号整数复制到新的 SV 中，可选择祝福 SV。 “房车”
参数将升级为 RV。 该 RV 将被修改为指向新的
SV。 “classname”参数表示祝福的包。 放
"classname" 为 "NULL" 避免了祝福。 新SV会有参考
计数为 1，将返回 RV。

SV* sv_setref_uv(SV *const rv,
const char *const 类名，
常量紫外线紫外线）

sv_setsv
将源 SV“ssv”的内容复制到目标 SV“dsv”。 这
如果源 SV 是致命的，它可能会被破坏，所以如果
源 SV 需要重用。 不处理目标 SV 上的“设置”魔法。
在源 SV 上调用“get”魔法。 松散地说，它执行按值复制，
删除目的地的任何先前内容。

您可能想要使用各种包装器之一，例如“SvSetSV”，
“SvSetSV_nosteal”、“SvSetMagicSV”和“SvSetMagicSV_nosteal”。

无效 sv_setsv(SV *dstr, SV *sstr)

sv_setsv_flags
将源 SV“ssv”的内容复制到目标 SV“dsv”。 这
如果源 SV 是致命的，它可能会被破坏，所以如果
源 SV 需要重用。 不处理“设置”魔法。 粗略地说，它
执行按值复制，删除目标的任何先前内容。
如果“flags”参数设置了“SV_GMAGIC”位，则“ssv”上的“mg_get”如果
合适，否则不合适。 如果“flags”参数设置了“SV_NOSTEAL”位，则
临时缓冲区不会被盗。 和“sv_setsv_nomg”是
根据这个功能实现。

您可能想要使用各种包装器之一，例如“SvSetSV”，
“SvSetSV_nosteal”、“SvSetMagicSV”和“SvSetMagicSV_nosteal”。

这是复制标量的主要功能，大多数其他复制
函数和宏在下面使用它。

无效 sv_setsv_flags(SV *dstr, SV *sstr,
const I32 标志）

sv_setsv_mg
像 "sv_setsv"，但也处理 'set' 魔法。

void sv_setsv_mg(SV *const dstr, SV *const sstr)

sv_setuv
将一个无符号整数复制到给定的 SV 中，如有必要，首先升级。 做
不处理“设置”魔法。 另见“sv_setuv_mg”。

void sv_setuv(SV *const sv, const UV num)

sv_setuv_mg
像 "sv_setuv"，但也处理 'set' 魔法。

void sv_setuv_mg(SV *const sv, const UV u)

sv_污点
测试 SV 的污染。 请改用“SvTAINTED”。

bool sv_tainted(SV *const sv)

sv_true 如果 SV 根据 Perl 的规则具有真值，则返回真。 使用“SvTRUE”宏
相反，它可能会调用“sv_true()”，或者可能会使用内联版本。

I32 sv_true(SV *const sv)

sv_unmagic
从 SV 中移除所有类型为“type”的魔法。

int sv_unmagic(SV *const sv, const int 类型)

sv_unmagicext
从 SV 中移除所有具有指定“vtbl”的“type”类型的魔法。

int sv_unmagicext(SV *const sv, const int 类型,
MGVTBL *vtbl)

sv_unref_flags
取消设置 SV 的 RV 状态，并减少任何之前的引用计数
被 RV 引用。 这几乎可以被认为是一个逆转
“新SVrv”。 “cflags”参数可以包含“SV_IMMEDIATE_UNREF”来强制
要递减的引用计数（否则递减取决于
引用计数不同于 XNUMX 或引用是只读的
SV）。 请参见“SvROK_off”。

void sv_unref_flags(SV *const ref, const U32 标志)

sv_untaint
清除 SV。 请改用“SvTAINTED_off”。

无效 sv_untaint(SV *const sv)

sv_升级
将 SV 升级为更复杂的形式。 一般为 SV 增加一个新的体型，
然后从旧身体中复制尽可能多的信息。 它发出嘶哑的声音
如果 SV 已经是比请求更复杂的形式。 你通常想要
使用“SvUPGRADE”宏包装器，它在调用之前检查类型
“sv_upgrade”，因此不会发牢骚。 另见“svtype”。

void sv_upgrade(SV *const sv, svtype new_type)

sv_usepvn_flags
告诉 SV 使用“ptr”来查找其字符串值。 通常存储字符串
在 SV 内部，但 sv_usepvn 允许 SV 使用外部字符串。 “ptr”
应该指向 Newx 分配的内存。 它必须是一个开始
Newx-ed 内存块，而不是指向它中间的指针（注意 OOK 和
写时复制），而不是来自像“malloc”这样的非Newx内存分配器。 这
必须提供字符串长度“len”。 默认情况下，此功能将“续订”
（即重新分配，移动）“ptr”指向的内存，所以指针不应该是
在将其提供给 sv_usepvn 后由程序员释放或使用，也不应该
使用该指针“后面”的任何指针（例如 ptr + 1）。

如果 "flags" & SV_SMAGIC 为真，将调用 SvSETMAGIC。 如果“标志”&
SV_HAS_TRAILING_NUL 为真，则“ptr[len]”必须为“NUL”，realloc 将
被跳过（即缓冲区实际上至少比“len”长 1 个字节，并且
已经满足存储在“SvPVX”中的要求）。

void sv_usepvn_flags(SV *const sv, char* ptr,
const STRLEN 长度，
const U32 标志）

sv_utf8_解码
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

如果 SV 的 PV 是 UTF-8 中的八位字节序列，并且包含一个多字节
字符，“SvUTF8”标志打开，使其看起来像一个字符。 如果
PV 仅包含单字节字符，“SvUTF8”标志保持关闭。 扫描
PV 表示有效性，如果 PV 是无效的 UTF-8，则返回 false。

bool sv_utf8_decode(SV *const sv)

sv_utf8_降级
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

尝试将 SV 的 PV 从字符转换为字节。 如果 PV 包含
一个字节不能容纳的字符，此转换将失败； 在这种情况下，
要么返回假，要么，如果“fail_ok”不是真的，呱呱叫。

这不是通用的 Unicode 到字节编码接口：使用 Encode
扩展名。

bool sv_utf8_downgrade(SV *const sv,
常量布尔fail_ok）

sv_utf8_编码
将 SV 的 PV 转换为 UTF-8，然后关闭“SvUTF8”标志，以便它
看起来又像八位字节了。

无效 sv_utf8_encode(SV *const sv)

sv_utf8_升级
将 SV 的 PV 转换为其 UTF-8 编码形式。 强制 SV 为字符串形式
如果还没有。 如果合适，将在“sv”上“mg_get”。 总是设置
SvUTF8 标志以避免将来的有效性检查，即使整个字符串是相同的
在UTF-8中不是。 返回转换后的字符串中的字节数

这不是 Unicode 接口的通用字节编码：使用 Encode
扩展名。

STRLEN sv_utf8_upgrade(SV *sv)

sv_utf8_upgrade_flags
将 SV 的 PV 转换为其 UTF-8 编码形式。 强制 SV 为字符串形式
如果还没有。 始终设置 SvUTF8 标志以避免将来的有效性检查
即使所有字节在 UTF-8 中都是不变的。 如果 "flags" 设置了 "SV_GMAGIC" 位，
如果合适，将在“sv”上“mg_get”，否则不会。

如果 "flags" 设置了 SV_FORCE_UTF8_UPGRADE，则此函数假定 PV 将
转换为 UTF-8 时展开，并跳过检查的额外工作。
通常，此标志由已解析字符串的例程使用，并且
找到了这样的字符，并将这些信息传递给该作品
必须重复。

返回转换后的字符串中的字节数。

这不是 Unicode 接口的通用字节编码：使用 Encode
扩展名。

STRLEN sv_utf8_upgrade_flags(SV *const sv,
const I32 标志）

sv_utf8_upgrade_flags_grow
与 sv_utf8_upgrade_flags 类似，但多了一个参数“extra”，即
'sv' 字符串保证在它之后有空闲的未使用字节数
返回。 这允许调用者保留它打算填充的额外空间，以
避免额外的增长。

“sv_utf8_upgrade”、“sv_utf8_upgrade_nomg”和“sv_utf8_upgrade_flags”是
根据这个功能实现。

返回转换后的字符串中的字节数（不包括备用）。

STRLEN sv_utf8_upgrade_flags_grow(SV *const sv,
const I32 标志，
额外的STRLEN）

sv_utf8_upgrade_nomg
像 sv_utf8_upgrade，但不会对“sv”施展魔法。

STRLEN sv_utf8_upgrade_nomg(SV *sv)

sv_vcatpvf
处理其参数，如“vsprintf”，并将格式化的输出附加到 SV。
不处理“设置”魔法。 参见“sv_vcatpvf_mg”。

通常通过其前端“sv_catpvf”使用。

void sv_vcatpvf(SV *const sv, const char *const pat,
va_list *常量参数）

sv_vcatpvfn
void sv_vcatpvfn(SV *const sv, const char *const pat,
const STRLEN 模式，
va_list *const 参数，
SV **const svargs，const I32 svmax，
bool *const may_tainted)

sv_vcatpvfn_flags
处理其参数，如“vsprintf”，并将格式化的输出附加到 SV。
如果缺少 C 样式变量参数列表 (NULL)，则使用 SV 数组。
在启用污点检查的情况下运行时，如果结果通过“maybe_tainted”指示
不可信（通常是由于使用了语言环境）。

如果调用为“sv_vcatpvfn”或标志包括“SV_GMAGIC”，调用会变魔术。

通常通过其前端“sv_vcatpvf”和“sv_vcatpvf_mg”之一使用。

无效 sv_vcatpvfn_flags(SV *const sv,
常量字符*常量帕特，
const STRLEN 模式，
va_list *const 参数，
SV **常量变量，
常量 I32 svmax,
bool *const may_tainted,
const U32 标志）

sv_vcatpvf_mg
像“sv_vcatpvf”，但也处理“设置”魔法。

通常通过其前端“sv_catpvf_mg”使用。

无效 sv_vcatpvf_mg(SV *const sv,
常量字符*常量帕特，
va_list *常量参数）

sv_vsetpvf
像“sv_vcatpvf”一样工作，但将文本复制到 SV 中而不是附加它。
不处理“设置”魔法。 参见“sv_vsetpvf_mg”。

通常通过其前端“sv_setpvf”使用。

void sv_vsetpvf(SV *const sv, const char *const pat,
va_list *常量参数）

sv_vsetpvfn
像“sv_vcatpvfn”一样工作，但将文本复制到SV而不是附加它。

通常通过其前端“sv_vsetpvf”和“sv_vsetpvf_mg”之一使用。

void sv_vsetpvfn(SV *const sv, const char *const pat,
const STRLEN 模式，
va_list *const 参数，
SV **const svargs，const I32 svmax，
bool *const may_tainted)

sv_vsetpvf_mg
像“sv_vsetpvf”，但也处理“设置”魔法。

通常通过其前端“sv_setpvf_mg”使用。

无效 sv_vsetpvf_mg(SV *const sv,
常量字符*常量帕特，
va_list *常量参数）

统一 支持

perlguts 中的“Unicode 支持”对此 API 进行了介绍。

另请参阅“字符分类”和“字符大小写更改”。 各种功能
本节之外的部分也特别适用于 Unicode。 在中搜索字符串“utf8”
这个文件。

字节_cmp_utf8
将“b”、“blen”中的字符序列（存储为八位字节）与
“u”、“ulen”中的字符序列（存储为 UTF-8）。 如果它们是则返回 0
相等，如果第一个字符串小于第二个字符串，则为 -1 或 -2，如果为 +1 或 +2
第一个字符串大于第二个字符串。

如果较短的字符串与开头相同，则返回 -1 或 +1
更长的字符串。 如果字符之间存在差异，则返回 -2 或 +2
弦内。

int bytes_cmp_utf8(const U8 *b, STRLEN blen,
const U8 *u, STRLEN 乌伦)

来自 utf8 的字节数
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将长度为“len”的字符串“s”从 UTF-8 转换为本机字节编码。
不像“utf8_to_bytes”，但像“bytes_to_utf8”，返回一个指向新的指针——
创建字符串，并更新“len”以包含新长度。 退回原件
字符串如果没有发生转换，“len”不变。 如果“is_utf8”什么也不做
指向 0。如果“s”被转换或完全由以下组成，则将“is_utf8”设置为 0
utf8 中不变的字符（即非 EBCDIC 机器上的 US-ASCII）。

U8* bytes_from_utf8(const U8 *s, STRLEN *len,
布尔 *is_utf8)

字节转utf8
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将长度为“len”字节的字符串“s”从本机编码转换为 UTF-8。
返回指向新创建字符串的指针，并设置“len”以反映新创建的字符串
字节长度。

字符串末尾将写入“NUL”字符。

如果您想从本机以外的编码转换为 UTF-8（Latin1 或
EBCDIC），见“sv_recode_to_utf8”（）。

U8* bytes_to_utf8(const U8 *s, STRLEN *len)

DO_UTF8 返回一个布尔值，给出“sv”中的 PV 是否被视为
以 UTF-8 编码。

你应该用这个 after 调用“SvPV()”或其变体之一，以防万一
对字符串重载的调用会更新内部 UTF-8 编码标志。

布尔 DO_UTF8(SV* sv)

折叠EQ_utf8
如果字符串“s1”和“s2”的前导部分（其中一个或两者都
其中可能是 UTF-8) 是相同的，不区分大小写； 否则为假。 如何
far into 要比较的字符串由其他输入参数确定。

如果 "u1" 为真，则假定字符串 "s1" 为 UTF-8 编码的 Unicode；
否则假定为原生 8 位编码。 对应于“u2”
关于“s2”。

如果字节长度“l1”不为零，它表示在“s1”中检查折叠的距离
平等。 换句话说，“s1”+“l1”将被用作达到的目标。 扫描
除非达到目标，否则不会被视为匹配，并且扫描
不会继续超过那个目标。 对应于“l2”相对于“s2”。

如果 "pe1" 是非 NULL 并且它指向的指针不是 NULL，则该指针是
被视为指向“s1”中最大点后 1 个字节位置的结束指针
超出此范围，在任何情况下都不会继续扫描。 （这个套路
假设 UTF-8 编码的输入字符串没有格式错误； 格式错误的输入可以
使其读取过去的“pe1”）。 这意味着如果“l1”和“pe1”都是
指定，并且“pe1”小于“s1”+“l1”，匹配永远不会成功
因为它永远无法达到它的目标（实际上被断言反对）。
对应于“pe2”相对于“s2”。

“s1”和“s2”中的至少一个必须有一个目标（“l1”和“l2”中的至少一个必须
是非零），如果两者都这样做，则必须达到两者才能成功匹配。
另外，如果一个字符的折叠是多个字符，它们都必须是
匹配（有关“折叠”，请参阅下面的 tr21 参考）。

匹配成功后，如果“pe1”不为 NULL，它将被设置为指向
的开始 下页 “s1”的字符超出了匹配的范围。 相应地
对于“pe2”和“s2”。

为了不区分大小写，使用 Unicode 的“大小写折叠”而不是
大写/小写两个字符，请参阅
<http://www.unicode.org/unicode/reports/tr21/>（案例映射）。

I32 FoldEQ_utf8(const char *s1, char **pe1, UV l1,
布尔 u1，常量字符 *s2，字符 **pe2，
UV l2，布尔值 u2)

是UTF8_CHAR
返回以“s”开头的字节数，形成合法的 UTF-8（或 UTF-
EBCDIC) 编码字符，仅将“e - s”字节转换为“s”。
如果从 "s" 到 "e - 0" 的序列不是格式正确的 UTF-1，则返回 8

请注意，INVARIANT 字符（即非 EBCDIC 机器上的 ASCII）是有效的
UTF-8 字符。

STRLEN isUTF8_CHAR(const U8 *s, const U8 *e)

is_ascii_字符串
这是“is_invariant_string”的误导性同义词。 在 ASCII 上
平台，名称不会误导：ASCII 范围的字符正是
UTF-8 不变量。 但是 EBCDIC 机器有更多的不变量，而不仅仅是 ASCII
字符，因此首选“is_invariant_string”。

bool is_ascii_string(const U8 *s, STRLEN len)

is_invariant_string
如果字符串 "s" 的前 "len" 字节相同，则返回 true
字符串的 UTF-8 编码（或 EBCDIC 机器上的 UTF-EBCDIC 编码）。
也就是说，如果它们是 UTF-8 不变的。 在 ASCII-ish 机器上，所有的 ASCII
字符，并且只有 ASCII 字符符合此定义。 在 EBCDIC 机器上，
ASCII 范围的字符是不变的，但 C1 控件和
“\C？” （不在 EBCDIC 的 ASCII 范围内）。

如果 "len" 为 0，它将使用 strlen(s) 计算，（这意味着如果你使用这个
选项，“s”不能嵌入“NUL”字符并且必须有一个
终止“NUL”字节）。

另请参见“is_utf8_string”()、“is_utf8_string_loclen”() 和
“is_utf8_string_loc”（）。

bool is_invariant_string(const U8 *s, STRLEN len)

is_utf8_字符串
如果字符串 "s" 的前 "len" 字节形成有效的 UTF-8 字符串，则返回 true，
否则为假。 如果 "len" 为 0，它将使用 strlen(s) 计算（其中
意味着如果您使用此选项，则“s”不能嵌入“NUL”字符并且
必须有一个终止的“NUL”字节）。 请注意，所有字符都是 ASCII
构成“有效的 UTF-8 字符串”。

另请参见“is_invariant_string”()、“is_utf8_string_loclen”() 和
“is_utf8_string_loc”（）。

bool is_utf8_string(const U8 *s, STRLEN len)

is_utf8_string_loc
与“is_utf8_string”类似，但存储失败的位置（在
“utf8ness failure”）或位置“s”+“len”（在“utf8ness success”的情况下）
在“ep”中。

另见“is_utf8_string_loclen”（）和“is_utf8_string”（）。

bool is_utf8_string_loc(const U8 *s, STRLEN len,
常量 U8 **ep)

is_utf8_string_loclen
与 "is_utf8_string"() 类似，但存储失败的位置（在
“utf8ness failure”）或位置“s”+“len”（在“utf8ness success”的情况下）
在“ep”中，以及在“el”中的 UTF-8 编码字符数。

另见“is_utf8_string_loc”（）和“is_utf8_string”（）。

bool is_utf8_string_loclen(const U8 *s, STRLEN len,
常量 U8 **ep, STRLEN *el)

pv_uni_显示
为标量“dsv”构建字符串“spv”的可显示版本，长度“len”，
可显示的版本最多为“pvlim”字节长（如果更长，其余为
截断并附加“...”）。

"flags" 参数可以将 UNI_DISPLAY_ISPRINT 设置为显示 是打印（）能够
字符本身，UNI_DISPLAY_BACKSLASH 将 \\[nrfta\\] 显示为
反斜杠版本（如 '\n'）（UNI_DISPLAY_BACKSLASH 优先于
UNI_DISPLAY_ISPRINT 为 \\)。 UNI_DISPLAY_QQ（及其别名 UNI_DISPLAY_REGEX）
同时打开 UNI_DISPLAY_BACKSLASH 和 UNI_DISPLAY_ISPRINT。

返回指向“dsv”的 PV 的指针。

另见“sv_uni_display”。

char* pv_uni_display(SV *dsv, const U8 *spv,
STRLEN 莱恩，STRLEN pvlim，
紫外线标志）

sv_cat_解码
假设编码是一个Encode对象，假设ssv的PV为
编码和解码中的八位字节输入从以下位置开始（PV
+ *offset) 指向。 dsv 将连接解码后的 UTF-8 字符串
ssv。 当字符串 tstr 出现在解码输出中或
输入在 ssv 的 PV 上结束。 偏移点的值
修改为 ssv 上的最后一个输入位置。

如果找到终止符，则返回 TRUE，否则返回 FALSE。

bool sv_cat_decode(SV* dsv, SV *编码, SV *ssv,
int *offset、char* tstr、int tlen)

sv_recode_to_utf8
假设编码是一个 Encode 对象，进入时 sv 的 PV 是
假定为该编码中的八位字节，并且 sv 将被转换为 Unicode
（和 UTF-8）。

如果 sv 已经是 UTF-8（或者不是 POK），或者编码不是
参考，对 sv 没有做任何事情。 如果编码不是“Encode::XS”
编码对象，会发生不好的事情。 （看 库/编码.pm 和编码。）

返回 sv 的 PV。

char* sv_recode_to_utf8(SV* sv, SV *编码)

sv_uni_显示
为标量“dsv”构建标量“sv”的可显示版本，
可显示的版本最多为“pvlim”字节长（如果更长，其余为
截断并附加“...”）。

“flags”参数与“pv_uni_display”() 中的一样。

返回指向“dsv”的 PV 的指针。

字符* sv_uni_display(SV *dsv, SV *ssv, STRLEN pvlim,
紫外线标志）

to_utf8_case
“p”包含指向 UTF-8 字符串的指针，该字符串对正在被编码的字符进行编码
转换。 该例程假定“p”处的字符格式正确。

"ustrp" 是一个指向字符缓冲区的指针，用来存放转换结果。
“lenp”是一个指向结果长度的指针。

“swashp”是一个指向要使用的斜体的指针。

特殊映射和法线映射都存储在 lib/unicore/To/Foo.pl和
由 SWASHNEW 加载，使用 lib/utf8_heavy.pl. “特殊”（通常，但不总是，
多字符映射），首先尝试。

“special”是一个字符串，通常是“NULL”或“”。 “NULL”表示不使用任何特殊的
映射； "" 表示使用特殊映射。 这两个以外的值是
被视为包含特殊映射的哈希的名称，例如
“utf8::ToSpecLower”。

"normal" 是一个类似于 "ToLower" 的字符串，表示花体 %utf8::ToLower。

UV to_utf8_case(const U8 *p, U8* ustrp,
STRLEN *lenp，SV **swashp，
const char *正常，
const char *特殊）

to_utf8_fold
而是使用“toFOLD_utf8”。

UV to_utf8_fold(const U8 *p, U8* ustrp,
斯特伦 *lenp)

to_utf8_lower
而是使用“toLOWER_utf8”。

UV to_utf8_lower(const U8 *p, U8* ustrp,
斯特伦 *lenp)

to_utf8_标题
而是使用“toTITLE_utf8”。

UV to_utf8_title(const U8 *p, U8* ustrp,
斯特伦 *lenp)

to_utf8_upper
而是使用“toUPPER_utf8”。

UV to_utf8_upper(const U8 *p, U8* ustrp,
斯特伦 *lenp)

utf8n_to_uvchr
此功能应仅在非常特殊的情况下使用。 大多数代码
应该使用 "utf8_to_uvchr_buf"() 而不是直接调用它。

底层 UTF-8 解码例程。 返回本机代码点值
字符串“s”中的第一个字符，假定为 UTF-8（或 UTF-EBCDIC）
编码，并且不超过“curlen”字节； *retlen（如果“retlen”不为 NULL）将
设置为该字符的长度（以字节为单位）。

“flags”的值决定了“s”不指向井时的行为——
形成 UTF-8 字符。 如果 "flags" 为 0，则当发现畸形时，零是
返回并设置 *retlen 以便 ("s" + *retlen) 是下一个可能的位置
在“s”中，可以开始一个非格式错误的字符。 此外，如果 UTF-8 警告
没有被词法禁用，会发出警告。

可以在“标志”中设置各种 ALLOW 标志以允许（而不是警告）个别
类型的畸形，例如序列过长（即，当有
是一个较短的序列，可以表达相同的代码点； 过长的序列是
由于潜在的安全问题，在 UTF-8 标准中明确禁止）。
另一个畸形示例是字符的第一个字节不是合法的
第一个字节。 看 utf8.h 对于此类标志的列表。 对于允许的 0 长度字符串，
此函数返回 0； 对于允许的超长序列，计算的代码点
被退回； 对于所有其他允许的畸形，Unicode REPLACEMENT
返回 CHARACTER，因为它们没有可确定的合理值。

UTF8_CHECK_ONLY 标志会覆盖当不允许（其他
flags) 发现畸形。 如果设置了此标志，则例程假定
调用者会发出警告，这个函数会默默地设置“retlen”为
“-1”（转换为“STRLEN”）并返回零。

请注意，此 API 需要在成功解码“NUL”之间消除歧义
字符，并返回错误（除非设置了 UTF8_CHECK_ONLY 标志），如
在这两种情况下，都返回 0。 为了消除歧义，在零回报时，看看第一个
“s”的字节也是 0。 如果是，则输入为“NUL”； 如果没有，输入有一个
错误。

某些代码点被认为是有问题的。 这些是 Unicode 代理，
Unicode 非字符，以及高于 Unicode 最大值 0x10FFFF 的代码点。 经过
默认这些被认为是常规代码点，但在某些情况下需要
对他们进行特殊处理。 如果“标志”包含 UTF8_DISALLOW_ILLEGAL_INTERCHANGE，
所有三个类别都被视为畸形并按此处理。 旗帜
UTF8_DISALLOW_SURROGATE、UTF8_DISALLOW_NONCHAR 和 UTF8_DISALLOW_SUPER（意思是
高于合法的 Unicode 最大值）可以设置为禁止这些类别
个别。

标志 UTF8_WARN_ILLEGAL_INTERCHANGE、UTF8_WARN_SURROGATE、UTF8_WARN_NONCHAR、
和 UTF8_WARN_SUPER 将导致针对它们各自的引发警告消息
类别，但否则代码点被认为是有效的（不是
畸形）。 让一个类别既被视为畸形又被提升
警告，请同时指定 WARN 和 DISALLOW 标志。 （但请注意，警告是
如果词法禁用或还指定了 UTF8_CHECK_ONLY，则不会引发。）

非常大的代码点（高于 0x7FFF_FFFF）被认为比
其他高于 Unicode 法定最大值的。 有几个原因：
它们要求至少 32 位在 ASCII 平台上表示它们，不是
在 EBCDIC 平台和原始 UTF-8 规范上完全可以表示
从来没有超过这个数字（当前的 0x10FFFF 限制是后来强加的）。 （这
较小的，适合 32 位的，可以用 ASCII 上的 UV 表示
平台，但不是通过 IV，这意味着可以进行的操作数
对它们执行的操作受到很大限制。）ASCII 平台上的 UTF-8 编码
这些大代码点以包含 0xFE 或 0xFF 的字节开始。 这
UTF8_DISALLOW_FE_FF 标志将导致它们被视为畸形，而
允许更小的高于 Unicode 的代码点。 （当然 UTF8_DISALLOW_SUPER 会
将所有上述 Unicode 代码点（包括这些代码点）视为畸形。）
同样，UTF8_WARN_FE_FF 的行为与其他 WARN 标志一样，但仅适用
到这些代码点。

与 Unicode 字符对应的所有其他代码点，包括私人使用
而那些尚未分配的，永远不会被认为是畸形的，也不会发出警告。

UV utf8n_to_uvchr(const U8 *s, STRLEN curlen,
STRLEN *retlen，U32 标志）

utf8n_to_uvuni
而是使用“utf8_to_uvchr_buf”，或者很少使用“utf8n_to_uvchr”。

此函数对于想要同时处理 EBCDIC 和 ASCII 的代码很有用
具有 Unicode 属性的平台，但从 Perl v5.20 开始，区别
平台之间的大部分代码对大多数代码都是不可见的，所以这
功能不太可能是您想要的。 如果你确实需要这个精确的
功能，请改用“NATIVE_TO_UNI(utf8_to_uvchr_buf(...))”或
“NATIVE_TO_UNI(utf8n_to_uvchr(...))”。

UV utf8n_to_uvuni(const U8 *s, STRLEN curlen,
STRLEN *retlen，U32 标志）

UTF8跳过
返回 UTF-8 编码字符中的字节数，其第一个（也许
仅）字节由“s”指向。

STRLEN UTF8SKIP(字符* s)

utf8_距离
返回 UTF-8 指针“a”和“b”之间的 UTF-8 字符数。

警告：仅当您*知道*指针指向相同的 UTF-8 内时才使用
缓冲。

IV utf8_distance(const U8 *a, const U8 *b)

utf8_跳
返回被“off”字符替换的 UTF-8 指针“s”，无论是向前还是
落后。

警告：除非您*知道*“off”在 UTF-8 数据中，否则请勿使用以下内容
由 "s" *and* 指向的条目 "s" 在第一个字节上对齐
字符或字符的最后一个字节之后。

U8* utf8_hop(常量 U8 *s, I32 关闭)

utf8_长度
返回以字符为单位的 UTF-8 char 编码字符串“s”的长度。 停在
“e”（含）。 如果 "e < s" 或者扫描结束后会超过 "e"，就会发出呱呱叫声。

STRLEN utf8_length(const U8* s, const U8 *e)

utf8 转字节
注意：此功能是实验性的，可能会更改或删除，恕不另行通知。

将长度为“len”的字符串“s”从 UTF-8 转换为本机字节编码。
与“bytes_to_utf8”不同，这会覆盖原始字符串，并将“len”更新为
包含新的长度。 失败时返回零，将“len”设置为 -1。

如果您需要字符串的副本，请参阅“bytes_from_utf8”。

U8* utf8_to_bytes(U8 *s, STRLEN *len)

utf8_to_uvchr_buf
返回字符串“s”中第一个字符的本机代码点，即
假定为 UTF-8 编码； "send" 指向 "s" 末尾之后的 1。
*retlen 将设置为该字符的长度（以字节为单位）。

如果“s”不指向格式正确的 UTF-8 字符并且 UTF8 警告是
启用时，返回零并将 *retlen 设置（如果“retlen”不为 NULL）为 -1。 如果
那些警告关闭，计算值，如果定义明确（或 Unicode
REPLACEMENT CHARACTER 如果不是），静默返回，并设置 *retlen（如果
"retlen" 不是 NULL)，因此 ("s" + *retlen) 是 "s" 中的下一个可能位置
这可能会开始一个非格式错误的字符。 有关详细信息，请参阅“utf8n_to_uvchr”
当 REPLACEMENT CHARACTER 返回时。

UV utf8_to_uvchr_buf(const U8 *s, const U8 *send,
STRLEN *retlen)

utf8_to_uvuni_buf
已弃用！ 计划从 Perl 的未来版本中删除此功能。
不要将它用于新代码； 从现有代码中删除它。

只有在极少数情况下，代码才需要处理 Unicode（如
与本机相反）代码点。 在这少数情况下，使用
"NATIVE_TO_UNI(utf8_to_uvchr_buf(...))" 代替。

返回字符串中第一个字符的 Unicode（非本地）代码点
"s" 假定为 UTF-8 编码； "send" 指向结束后的 1
“s”。 “retlen”将设置为该字符的长度（以字节为单位）。

如果“s”不指向格式正确的 UTF-8 字符并且 UTF8 警告是
启用时，返回零并将 *retlen 设置（如果“retlen”不为 NULL）为 -1。 如果
这些警告关闭，计算值（如果定义明确）（或 Unicode
REPLACEMENT CHARACTER，如果不是的话）被静默返回，并且 *retlen 被设置（如果
"retlen" 不是 NULL)，因此 ("s" + *retlen) 是 "s" 中的下一个可能位置
这可能会开始一个非格式错误的字符。 有关详细信息，请参阅“utf8n_to_uvchr”
当 REPLACEMENT CHARACTER 返回时。

UV utf8_to_uvuni_buf(const U8 *s, const U8 *send,
STRLEN *retlen)

UVCHR_SKIP
返回编码时表示代码点“cp”所需的字节数
作为 UTF-8。 如果小于 255，“cp”是本机（ASCII 或 EBCDIC）代码点； 一个
否则为 Unicode 代码点。

STRLEN UVCHR_SKIP(UV cp)

uvchr_to_utf8
将本机代码点“uv”的 UTF-8 表示添加到
字符串“d”； “d”应该至少有“UVCHR_SKIP(uv)+1”（最高到“UTF8_MAXBYTES+1”）
可用的免费字节。 返回值是指向结束后字节的指针
的新角色。 换句话说，

d = uvchr_to_utf8(d, uv);

是推荐的广泛的本地字符感知方式

*(d++) = 紫外线；

此函数接受任何 UV 作为输入。 禁止或警告非 Unicode 代码
点或可能有问题的点，请参阅“uvchr_to_utf8_flags”。

U8* uvchr_to_utf8(U8 *d, UV 紫外线)

uvchr_to_utf8_flags
将本机代码点“uv”的 UTF-8 表示添加到
字符串“d”； “d”应该至少有“UVCHR_SKIP(uv)+1”（最高到“UTF8_MAXBYTES+1”）
可用的免费字节。 返回值是指向结束后字节的指针
的新角色。 换句话说，

d = uvchr_to_utf8_flags(d, uv, 标志);

或者，在大多数情况下，

d = uvchr_to_utf8_flags(d, uv, 0);

这是 Unicode 感知的说法

*(d++) = 紫外线；

此函数将转换为 UTF-8（而不是警告），即使代码点不是
合法的 Unicode 或有问题，除非“标志”包含一个或多个
以下标志：

如果 "uv" 是 Unicode 代理代码点并且设置了 UNICODE_WARN_SURROGATE，则
如果启用了 UTF8 警告，函数将发出警告。 如果相反
设置了UNICODE_DISALLOW_SURROGATE，函数将失败并返回NULL。 如果
两个标志都设置了，该函数将发出警告并返回 NULL。

UNICODE_WARN_NONCHAR 和 UNICODE_DISALLOW_NONCHAR 标志影响
函数处理 Unicode 非字符。 同样，UNICODE_WARN_SUPER
和 UNICODE_DISALLOW_SUPER 标志会影响上述代码点的处理
Unicode 最大值 0x10FFFF。 高于 0x7FFF_FFFF 的代码点（偶数
可移植性较差）可以被警告和/或禁止，即使其他高于 Unicode 代码
UNICODE_WARN_FE_FF 和 UNICODE_DISALLOW_FE_FF 标志接受点。

最后，标志 UNICODE_WARN_ILLEGAL_INTERCHANGE 选择所有四个
上面的警告标志； 并且 UNICODE_DISALLOW_ILLEGAL_INTERCHANGE 选择所有四个
禁止标志。

U8* uvchr_to_utf8_flags(U8 *d, UV uv, UV 标志)

uvoffuni_to_utf8_flags
此功能应仅在非常特殊的情况下使用。 反而，
几乎 所有 码 应该 使用 “uvchr_to_utf8” or “uvchr_to_utf8_flags”.

这个函数和他们一样，但是输入是一个严格的 Unicode（而不是
本机）代码点。 只有在极少数情况下，代码才不应使用
本机代码点。

有关详细信息，请参阅“uvchr_to_utf8_flags”的说明。

U8* uvoffuni_to_utf8_flags(U8 *d, UV uv, UV 标志)

uvuni_to_utf8_flags
相反，您几乎可以肯定要使用“uvchr_to_utf8”或“uvchr_to_utf8_flags”。

此函数是“uvoffuni_to_utf8_flags”的弃用同义词，它本身，
虽然没有被弃用，但只能在孤立的情况下使用。 这些
函数对于想要同时处理 EBCDIC 和 ASCII 的代码很有用
具有 Unicode 属性的平台，但从 Perl v5.20 开始，区别
平台之间的大部分代码对大多数代码都是不可见的，所以这
功能不太可能是您想要的。

U8* uvuni_to_utf8_flags(U8 *d, UV uv, UV 标志)

变量 创建 by “xsubpp” 和 “xsubpp” 内部 功能

新XSproto
由“xsubpp”用来将 XSUB 连接为 Perl 子。 将 Perl 原型添加到 subs。

XS_APIVERSION_BOOTCHECK
用于验证 XS 模块已针对 perl api 版本编译的宏
匹配它被加载到的 perl 解释器的 api 版本。

XS_APIVERSION_BOOTCHECK；

XS_版本
XS 模块的版本标识符。 这通常由自动处理
“ExtUtils::MakeMaker”。 请参阅“XS_VERSION_BOOTCHECK”。

XS_VERSION_BOOTCHECK
用于验证 PM 模块的 $VERSION 变量是否与 XS 模块的变量匹配的宏
“XS_VERSION”变量。 这通常由“xsubpp”自动处理。 看
perlxs 中的“VERSIONCHECK：关键字”。

XS_VERSION_BOOTCHECK；

版本

新版本
根据传入的 SV 返回一个新的版本对象：

SV *sv = new_version(SV *ver);

不改变传入的版本 SV。 如果要升级，请参阅“upg_version”
SV。

SV* new_version(SV *版本)

预扫描版本
验证给定的字符串是否可以解析为版本对象，但不能
实际执行解析。 可以使用严格或宽松的验证规则。 能
可选地设置一些提示变量以在某些时候保存解析代码
标记化。

const char* prescan_version(const char *s, bool strict,
常量字符** errstr，
布尔 *sqv,
int *ssaw_decimal，
int *swidth，布尔 *salpha)

扫描版本
在解析的版本字符串之后返回一个指向下一个字符的指针，以及
就像将传入的 SV 升级为 RV。

必须使用已经存在的 SV 调用函数，例如

SV = 新SV（0）;
s = scan_version(s, SV *sv, bool qv);

对字符串执行一些预处理以确保它具有正确的
一个版本的特点。 如果对象包含下划线，则标记该对象
（表示这是一个 alpha 版本）。 布尔值 qv 表示版本
应该被解释为它有多个小数，即使它没有。

const char* scan_version（const char *s，SV *rv，bool qv）

升级版本
将提供的 SV 就地升级到版本对象。

SV *sv = upg_version(SV *sv, bool qv);

返回指向升级的 SV 的指针。 如果你想强制设置布尔值 qv
此 SV 被解释为“扩展”版本。

SV* upg_version(SV *ver, bool qv)

vcmp 版本对象感知 cmp。 两个操作数必须已经转换为
版本对象。

int vcmp(SV *lhv, SV *rhv)

vnormal 接受版本对象并返回规范化的字符串表示。 称呼
喜欢：

sv = vnormal(rv);

注意：您可以直接传递对象，也可以传递 RV 中包含的 SV。

返回的 SV 的引用计数为 1。

SV* 正常值(SV *vs)

vnumify 接受版本对象并返回规范化的浮点表示。
像这样调用：

sv = vnumify(rv);

注意：您可以直接传递对象，也可以传递 RV 中包含的 SV。

返回的 SV 的引用计数为 1。

SV* vnumify(SV *vs)

字符串化
为了保持与 Perl 早期版本的最大兼容性，这
函数将返回浮点表示法或多个点
符号，取决于原始版本是否包含 1 个或多个点，
。

返回的 SV 的引用计数为 1。

SV* vstringify(SV *vs)

vverify 验证 SV 是否包含版本对象的有效内部结构。 它
可以传递版本对象 (RV) 或散列本身 (HV)。 如果
结构是有效的，它返回 HV。 如果结构无效，则返回
空值。

SV *hv = vverify(sv);

请注意，它仅确认了最小的结构（以免混淆
通过可能包含附加哈希条目的派生类）：

SV* v验证(SV *vs)

警告 和 死亡

croak 这是 Perl 的“die”函数的 XS 接口。

采用 sprintf 风格的格式模式和参数列表。 这些用于生成
字符串消息。 如果消息不以换行符结尾，那么它将是
扩展了代码中当前位置的一些指示，如所述
对于“mess_sv”。

错误消息将被用作异常，默认情况下将控制权返回给
最近的封闭“eval”，但受 $SIG{__DIE__} 修改
处理程序。 无论如何，“croak”函数永远不会正常返回。

由于历史原因，如果 "pat" 为空，则 "ERRSV" ($@) 的内容将为
用作错误消息或对象，而不是从中构建错误消息
论据。 如果你想抛出一个非字符串对象，或者在
自己是 SV，最好使用“croak_sv”函数，它不会
涉及破坏“ERRSV”。

void croak(const char *pat, ...)

呱呱不修改
完全等价于 "Perl_croak(aTHX_ "%s", PL_no_modify)"，但生成更简洁
目标代码比使用“Perl_croak”。 在异常代码路径上使用的代码更少
降低 CPU 缓存压力。

无效 croak_no_modify()

呱呱叫声
这是 Perl 的“die”函数的 XS 接口。

“baseex”是错误消息或对象。 如果它是参考，它将被使用
原样。 否则它被用作一个字符串，如果它不以换行符结尾
然后它将扩展代码中当前位置的一些指示，
如“mess_sv”所述。

错误消息或对象将被用作异常，默认返回
控制到最近的封闭“eval”，但受制于修改
$SIG{__DIE__} 处理程序。 无论如何，“croak_sv”函数永远不会返回
一般。

要死一个简单的字符串消息，“呱呱”功能可能更方便。

无效 croak_sv(SV *baseex)

die 行为与 "croak" 相同，但返回类型除外。 它应该只使用
其中需要“OP *”返回类型。 该函数从未真正返回。

OP *死（const char * pat，...）

die_sv 行为与“croak_sv”相同，但返回类型除外。 应该使用
仅在需要“OP *”返回类型的地方。 该功能实际上从未
回报。

OP * die_sv(SV *baseex)

vcroak 这是 Perl 的“死”函数的 XS 接口。

"pat" 和 "args" 是 sprintf 风格的格式模式和封装的参数
列表。 这些用于生成字符串消息。 如果消息没有结束
使用换行符，然后它将扩展为当前的一些指示
代码中的位置，如“mess_sv”所述。

错误消息将被用作异常，默认情况下将控制权返回给
最近的封闭“eval”，但受 $SIG{__DIE__} 修改
处理程序。 无论如何，“croak”函数永远不会正常返回。

由于历史原因，如果 "pat" 为空，则 "ERRSV" ($@) 的内容将为
用作错误消息或对象，而不是从中构建错误消息
论据。 如果你想抛出一个非字符串对象，或者在
自己是 SV，最好使用“croak_sv”函数，它不会
涉及破坏“ERRSV”。

void vcroak(const char *pat, va_​​list *args)

vwarn 这是 Perl 的“警告”功能的 XS 接口。

"pat" 和 "args" 是 sprintf 风格的格式模式和封装的参数
列表。 这些用于生成字符串消息。 如果消息没有结束
使用换行符，然后它将扩展为当前的一些指示
代码中的位置，如“mess_sv”所述。

默认情况下，错误消息或对象将写入标准错误，但这
受 $SIG{__WARN__} 处理程序的修改。

与“vcroak”不同，“pat”不允许为空。

void vwarn(const char *pat, va_​​list *args)

warn 这是 Perl 的“警告”函数的 XS 接口。

采用 sprintf 风格的格式模式和参数列表。 这些用于生成
字符串消息。 如果消息不以换行符结尾，那么它将是
扩展了代码中当前位置的一些指示，如所述
对于“mess_sv”。

默认情况下，错误消息或对象将写入标准错误，但这
受 $SIG{__WARN__} 处理程序的修改。

与“croak”不同，“pat”不允许为空。

无效警告(const char *pat, ...)

warn_sv 这是 Perl 的“警告”函数的 XS 接口。

“baseex”是错误消息或对象。 如果它是参考，它将被使用
原样。 否则它被用作一个字符串，如果它不以换行符结尾
然后它将扩展代码中当前位置的一些指示，
如“mess_sv”所述。

默认情况下，错误消息或对象将写入标准错误，但这
受 $SIG{__WARN__} 处理程序的修改。

要使用简单的字符串消息进行警告，“警告”功能可能更方便。

无效warn_sv（SV *baseex）

无证 功能

以下函数已被标记为公共 API 的一部分，但目前
无证。 使用它们需要您自担风险，因为界面可能会发生变化。
本文档中未列出的功能不供公众使用，应
不得在任何情况下使用。

如果您使用以下未记录的功能之一，您可能希望考虑创建和
为其提交文件。 如果您的补丁被接受，这将表明
接口是稳定的（除非另有明确标记）。

获取变量
Gv_A更新
PerlIO_clearerr
PerlIO_close
PerlIO_context_layers
PerlIO_eof
PerlIO_错误
PerlIO_文件号
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_ptrnt
PerlIO_setlinebuf
PerlIO_stderr
PerlIO_stdin
PerlIO_标准输出
PerlIO_tell
PerlIO_未读
PerlIO_write
魔法呼叫
amagic_deref_call
任何_dup
atfork_lock
atfork_unlock
av_arylen_p
av_iter_p
块给我
call_atexit 退出
通话清单
卡洛克
演员表_i32
演员表_iv
演员_乌龙
投射UV
CK_华纳
ck_warner_d
提示
ckwarn_d
克隆参数删除
克隆参数新
呱呱叫内存包裹
croak_nocontext
处理程序
CX转储
CX_DUP
中新
DEB
deb_无上下文
debop
debprofdump
数据库堆栈
调试堆栈指针
迷路
发送信号
die_nocontext
迪普_dup
do_aspawn
do_bin模式
关闭
do_gv_dump
do_gvgv_dump
做_hv_dump
加入
做魔术转储
do_op_dump
打开
do_open9
do_openn
做_pmop_转储
do_spawn
do_spawn_nowait
do_sprintf
do_sv_dump
做污点
多雷夫
逆风
想要的数组
转储评估
转储表格
转储缩进
转储_mstats
转储子
转储文登
过滤器添加
过滤器删除
过滤器读取
折叠EQ_latin1
表单无上下文
fp_dup
fprintf_nocontext
自由全局结构
空闲时间
获取上下文
获取mstats
获取操作描述
获取操作名称
获取_ppaddr
获取vtbl
GP_DUP
gp_free
GP_参考
gv_AVadd
gv_HVadd
gv_IOadd
gv_SVadd
gv_add_by_type
gv_自动加载4
gv_自动加载_pv
gv_autoload_pvn
gv_自动加载_sv
gv_检查
gv_转储
gv_efullname
gv_efullname3
gv_efullname4
gv_fetchfile
gv_fetchfile_flags
gv_fetchpv
gv_fetchpvn_flags
gv_fetchsv
gv_全名
gv_全名3
gv_全名4
gv_处理程序
gv_名称_集
he_dup
hek_dup
hv_common
hv_common_key_len
hv_delayfree_ent
hv_eiter_p
hv_eiter_set
hv_free_ent
hv_ksplit
hv_名称_集
hv_placeholders_get
hv_placeholders_set
hv_rand_set
hv_riter_p
hv_riter_set
ibcmp_utf8
初始化全局结构
初始化堆栈
初始化_tm
INSTR
is_lvalue_sub
离开范围
加载模块无上下文
魔术转储
分配
标记堆栈增长
混乱无上下文
自由
毫克_dup
毫克大小
迷你时间
更多开关
mro_get_from_name
mro_get_private_data
mro_设置_mro
mro_set_private_data
我的_atof
我的_atof2
我的_bcopy
我的_bzero
我的大小
my_cxt_index
my_cxt_init
my_dirfd
我的_退出
我的失败退出
我的_fflush_all
我的叉子
我的_lstat
我的_memcmp
我的内存集
我的_pclose
我的_popen
我的_popen_列表
我的_setenv
我的套接字对
我的统计数据
my_strftime
新的ANONATTRSUB
新的ANONHASH
新匿名者名单
新ANONSUB
新属性
新AVREF
新CVREF
新表格
新GVREF
新GVgen
newGVgen_flags
新HVREF
新HVhv
新IO
新MYSUB
新程序
新房车
新SUB
新SVREF
newSVpvf_nocontext
新堆栈信息
宁斯特尔
op_refcnt_lock
op_refcnt_unlock
解析器_dup
perl_alloc_using
perl_clone_using
pmop_转储
弹出范围
预编译
预执行
无预浸料
预浸料2
printf_无上下文
ptr_table_fetch
ptr_table_free
ptr_table_new
ptr_表_分割
指针表存储
推送范围
重新编译
重新复制胆量
重新直觉开始
重新直觉字符串
重新分配
可重入自由
重入初始化
重入重试
可重入大小
文献
reg_named_buff_all
reg_named_buff_存在
reg_named_buff_fetch
reg_named_buff_firstkey
reg_named_buff_nextkey
reg_named_buff_标量
regclass_swash
注册转储
regdupe_内部
regexec_flags
regfree_内部
重新初始化颜色
新版
重复
管理器
信号
信号状态
运行调试
runops_标准
rvpv_dup
安全系统调用
安全系统免费
安全小号
安全系统重新分配
保存_I16
保存_I32
保存_I8
保存_删除
保存_aelem
保存_aelem_flags
保存分配
保存_aptr
保存目录
保存布尔
保存_清除
保存删除
保存析构函数
保存析构函数_x
保存自由操作
保存_freepv
保存_freesv
保存_generic_pvref
保存_generic_svref
保存_gp
保存哈希
保存删除
拯救舵手
保存_helem_flags
保存提示
保存_hptr
保存整数
保存项目
保存_iv
保存列表
保存长
save_mortalizesv
保存_nogv
保存操作
save_padsv_and_mortalize
保存_pptr
保存_pushi32ptr
save_pushtr
保存_pushptrptr
保存重新上下文
保存标量
保存设置_svflags
保存共享的pvref
保存_sptr
保存_svref
保存_vptr
保存堆栈增长
savestack_grow_cnt
扫描编号
扫描_vstring
种子
设置上下文
设置数字本地
设置数字基数
设置数字标准
共享_hek
si_dup
ss_dup
堆栈增长
开始子解析
字符串到版本
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
系统初始化
系统初始化3
sys_intern_清除
sys_intern_dup
系统实习生初始化
系统术语
污染环境
污点
解开
不共享
utf16_to_utf8
utf16_to_utf8_reversed
uvuni_to_utf8
弗德布
表格
加载模块
vnewSVpvf
华纳
warn_nocontext
华纳
警告_无上下文
哪个签名
哪个sig_pv
哪个sig_pvn
哪个sig_sv

作者

直到 1997 年 XNUMX 月，本文档由 Jeff Okamoto 维护[email protected]>. 这是
现在作为 Perl 本身的一部分进行维护。

在 Dean Roehrich、Malcolm Beattie、Andreas Koenig 的帮助和建议下，
保罗·哈德森、伊利亚·扎哈列维奇、保罗·马奎斯、尼尔·鲍尔斯、马修·格林、蒂姆·邦斯、
Spider Boardman、Ulrich Pfeifer、Stephen McCamant 和 Gurusamy Sarathy。

API 列表最初由 Dean Roehrich[email protected]>.

更新为由 Benjamin Stuhl 从源代码中的评论自动生成。

使用 onworks.net 服务在线使用 perlapi