模块契约Regex

错误

模块错误域为 xrt.regex。语法错误使用 XREGEX_ERROR_PATTERN,资源预算使用 XREGEX_ERROR_LIMIT。xrtRegexErrorOffset 可读取语法错误的模式字节位置。批量编译的语法、配置和预算错误会保留原始错误作为 cause,xrtRegexSetErrorIndex 返回失败模式的零基索引。内存不足不再尝试分配包装错误,而是原样传播稳定的 XERR_MEMORY。

模块

  • XRT_MODULE_REGEX:启用完整正则能力。
  • XRT_MODULE_REGEX_CORE:字面量转义、编译、元数据、资源预算和结构化错误。
  • XRT_MODULE_REGEX_MATCH:搜索、指定位置、完整匹配、遍历和捕获;依赖 Unicode 原语处理空匹配推进。
  • XRT_MODULE_REGEX_REPLACE:模板替换、回调替换和事务式字符串构建;依赖 matcher 与字符串构建器。
  • XRT_MODULE_REGEX_SPLIT:流式正则拆分与单块复制结果;依赖 matcher 和字符串拆分结果。
  • XRT_MODULE_REGEX_SET:把多个编译对象合并为一个执行程序,一次返回全部命中的模式索引。

编译

xrtRegexCompile 使用默认 1 MiB 模式预算和 4096 个捕获预算。xrtRegexCompileConfig 允许收紧预算并设置忽略大小写、多行、点匹配换行和非贪婪标志。模式和输入都是明确长度视图,不要求零结尾,并允许嵌入零字节;命名捕获名称是例外,名称不能为空、重复或包含零字节。

编译对象通过 xrtRegexRef 和 xrtRegexRelease 管理。模块不公开底层 builder、分配器或 clone;共享编译对象不需要克隆。

动态文本不能直接拼入表达式。xrtRegexEscapeSize 返回转义后的精确字节数,xrtRegexEscapeWrite 写入调用方缓冲区并支持输入、输出同址,xrtRegexEscape 返回由 xrtFree 释放的独立字符串。转义按字节保留普通内容,只为具有语法含义的 \\.+*?()|[]{}^$ 增加反斜杠,因此明确长度的二进制文本不会被截断。部分重叠的输入和输出会被拒绝。

匹配

所有匹配函数返回 xregexresult:

值含义
XREGEX_ERROR执行失败,读取 xrtGetError()
XREGEX_NONE正常完成但未匹配
XREGEX_MATCH匹配成功

xrtRegexMatcherFind 从给定字节位置搜索,xrtRegexMatcherAt 要求匹配从该位置开始,xrtRegexMatcherFull 要求覆盖完整输入。xrtRegexMatcherNext 遍历后续匹配;空匹配按一个合法 UTF-8 标量推进,无效序列按一个字节推进。

捕获范围统一使用半开字节区间 [Begin, End)。xregexcapture.Matched 区分“捕获未参与”与“捕获了空字符串”。捕获文本和 matcher 输入均为借用视图,在下一次匹配或 matcher 释放前有效。

替换

xrtRegexReplaceTo 是基础模板入口,把结果追加到已有 xstrbuf。iLimit 是最大替换次数,0 表示不替换,SIZE_MAX 表示全部替换。成功时可通过 pCount 取得实际次数;失败时,本次调用追加的内容全部撤销,进入函数前的构建器内容保持不变。输入和替换模板允许借用构建器当前有效内容,内部会在首次增长前稳定这些视图。

模板语法刻意保持精简:

写法含义
$0整体匹配
$1、$2数字捕获
${name}命名捕获
$$字面量美元符号

未参与匹配的可选捕获展开为空文本。无效索引、未知名称和不完整美元令牌在开始匹配前报告 XREGEX_ERROR_REPLACEMENT,xrtRegexErrorOffset 返回模板字节位置。

xrtRegexReplaceFuncTo 让回调读取当前 matcher 的全部捕获并直接向输出尾部追加内容,适合大小写转换、编码或数据驱动重写。回调只能追加,不得清空、收缩或接管构建器。回调失败同样撤销本次替换调用的全部输出。

xrtRegexReplace 与 xrtRegexReplaceFirst 是常见路径的一行式入口,返回由调用方使用 xrtFree 释放的零结尾字符串。需要保留嵌入零字节后的精确长度时使用 xrtRegexReplaceTo 并读取 xstrbuf.Size。

拆分

xrtRegexSplitterCreate 创建借用输入的流式拆分器,xrtRegexSplitterNext 以 XREGEX_MATCH / XREGEX_NONE / XREGEX_ERROR 返回字段。普通字段的 xregexsplitpart.Capture 为 XRT_NPOS;启用 XREGEX_SPLIT_CAPTURES 后,每次分隔匹配的捕获按组号紧随字段返回。捕获项用 Matched 区分未参与捕获和合法空捕获。

xregexsplitconfig.Limit 表示最多使用多少次分隔匹配:0 返回完整输入,SIZE_MAX 不限制。默认保留首尾及相邻分隔符产生的空字段;XREGEX_SPLIT_SKIP_EMPTY 会同时跳过空字段和空捕获。空分隔匹配沿用 matcher 的 UTF-8 标量推进规则,不会在同一字节位置循环。

xrtRegexSplit 是默认配置的便捷入口。它复用同一个 splitter 执行计数和写入两遍,返回与 xrtStrSplit 相同布局的 xstrlist:视图数组、各项零结尾副本和哨兵都位于一个分配块中,使用 xrtStrListFree 释放。需要限制、过滤或捕获元数据时使用流式接口。

集合匹配

xrtRegexSetCreate 接受已有 xregex,因此同一集合中的模式可以使用不同编译标志。集合会增加每个模式的引用;创建成功后,调用方可以立即释放原引用。xrtRegexSetCompile 和 xrtRegexSetCompileConfig 是共享配置的批量编译入口。空集合合法且始终返回 XREGEX_NONE。

xregexset 与 xregex 一样不可变并可跨线程共享。每个执行流使用自己的 xregexsetmatcher。xrtRegexSetMatcherMatch 从明确字节位置开始搜索,并以升序返回所有能够在剩余输入中命中的模式索引。xrtRegexSetMatcherCount、xrtRegexSetMatcherIndex、xrtRegexSetMatcherMatched 和 xrtRegexSetMatcherFirst 只读取最近一轮成功执行的结果,不复制输入或匹配文本。

集合适合规则分类、路由预筛和日志扫描。需要捕获内容时,先用集合取得候选模式,再使用 xregexmatcher 执行对应编译对象;这样集合热路径只维护模式索引,不为每个模式保存捕获数组。

语法与保证

支持 RE2 风格字符类、Unicode 属性、贪婪与非贪婪量词、命名捕获、行首尾和文本首尾断言,以及表达式内标志。表达式内标志为 i、m、s 和 U;引擎始终按 Unicode 模式工作,因此不接受会暗示切换 Unicode 模式的 u。字符类末尾的 - 按字面量处理,逆序范围属于语法错误。\b 和 \B 使用 ASCII 单词字符定义。

模块有意不支持反向引用和前后向环视。这些结构无法维持线性时间保证;需要这类语义时,应把正则用于候选定位,再由调用方执行二次检查。

示例

普通匹配示例位于 examples/text/regex/main.c,替换示例位于 examples/text/regex_replace/main.c,拆分示例位于 examples/text/regex_split/main.c,集合分类示例位于 examples/text/regex_set/main.c。

xregexflag类型

编译标志与表达式内的 (?i)、(?m)、(?s)、(?U) 语义一致。

值语义
XREGEX_IGNORE_CASEIGNORECASE
XREGEX_MULTILINEMULTILINE
XREGEX_DOT_ALLDOT全部
XREGEX_UNGREEDY非贪婪
typedef enum xregexflag { XREGEX_IGNORE_CASE = UINT32_C(0x00000001), XREGEX_MULTILINE = UINT32_C(0x00000002), XREGEX_DOT_ALL = UINT32_C(0x00000004), XREGEX_UNGREEDY = UINT32_C(0x00000008)

xregexresult类型

所有匹配入口使用同一三态结果,未匹配不属于错误。

值语义
XREGEX_ERROR失败
XREGEX_NONE无
XREGEX_MATCH命中
typedef enum xregexresult { XREGEX_ERROR = -1, XREGEX_NONE = 0, XREGEX_MATCH = 1 } xregexresult;

xregexerror类型

正则模块错误代码在 xrt.regex 域内保持稳定。

值语义
XREGEX_ERROR_CONFIG配置非法
XREGEX_ERROR_PATTERN失败
XREGEX_ERROR_LIMIT超限
XREGEX_ERROR_EXECUTE失败
XREGEX_ERROR_REPLACEMENT失败
XREGEX_ERROR_CALLBACK回调失败
typedef enum xregexerror { XREGEX_ERROR_CONFIG = 1501, XREGEX_ERROR_PATTERN, XREGEX_ERROR_LIMIT, XREGEX_ERROR_EXECUTE, XREGEX_ERROR_REPLACEMENT, XREGEX_ERROR_CALLBACK } xregexerror;

xregexconfig类型

编译配置同时控制语义标志与可由调用方收紧的资源预算。

字段类型语义
Flagsuint32标志位
MaxPatternBytessize_tMaxPatternBytes
MaxCapturessize_tMaxCaptures
typedef struct xregexconfig { uint32 Flags; size_t MaxPatternBytes; size_t MaxCaptures; uint32 Reserved[4]; } xregexconfig;

xregexspan类型

匹配范围使用零基半开字节区间 [Begin, End)。

字段类型语义
Beginsize_tBegin
Endsize_t结束
typedef struct xregexspan { size_t Begin; size_t End; } xregexspan;

xregexcapture类型

捕获记录区分未参与匹配与合法的空匹配。

字段类型语义
MatchedboolMatched
SpanxregexspanSpan
Textxstrview文本视图
typedef struct xregexcapture { bool Matched; xregexspan Span; xstrview Text; } xregexcapture;

xregexsplitflag类型

拆分标志控制捕获输出和空项过滤。

值语义
XREGEX_SPLIT_CAPTURESXREGEX按级别分流CAPTURES
XREGEX_SPLIT_SKIP_EMPTY跳过空字段
typedef enum xregexsplitflag { XREGEX_SPLIT_CAPTURES = UINT32_C(0x00000001), XREGEX_SPLIT_SKIP_EMPTY = UINT32_C(0x00000002)

xregexsplitconfig类型

Limit 是最多使用的分隔匹配数,SIZE_MAX 表示不限制。

字段类型语义
Limitsize_t上限
Flagsuint32标志位
typedef struct xregexsplitconfig { size_t Limit; uint32 Flags; uint32 Reserved[4]; } xregexsplitconfig;

xregexsplitpart类型

Capture 为 XRT_NPOS 时是普通字段,否则是捕获索引。

字段类型语义
Textxstrview文本视图
Capturesize_tCapture
MatchedboolMatched
typedef struct xregexsplitpart { xstrview Text; size_t Capture; bool Matched; } xregexsplitpart;

xregex类型

编译对象不可变、可跨线程共享并通过引用计数管理。 不透明句柄或别名;生命周期与所有权见各使用方 API 节。

typedef struct xregex xregex;

xregexmatcher类型

matcher 独占可变执行缓存,捕获视图在下一次匹配前有效。 不透明句柄或别名;生命周期与所有权见各使用方 API 节。

typedef struct xregexmatcher xregexmatcher;

xregexsplitter类型

流式拆分器借用输入,并独占一个可重用 matcher。 不透明句柄或别名;生命周期与所有权见各使用方 API 节。

typedef struct xregexsplitter xregexsplitter;

xregexset类型

编译集合不可变并持有各模式引用。 不透明句柄或别名;生命周期与所有权见各使用方 API 节。

typedef struct xregexset xregexset;

xregexsetmatcher类型

集合 matcher 独占执行缓存和本轮命中索引。 不透明句柄或别名;生命周期与所有权见各使用方 API 节。

typedef struct xregexsetmatcher xregexsetmatcher;

xregexreplacefn类型

自定义替换器只能向输出尾部追加内容,返回 false 表示终止并报告错误。 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef bool(*xregexreplacefn)( const xregexmatcher* pMatcher, xstrbuf* pOutput, ptr pUserData)
模块

xrtRegexEscapeSize函数

返回字面量文本转义为正则表达式后的精确字节数,不包含末尾零。

bool xrtRegexEscapeSize(xstrview Text, size_t* pOutputSize)

参数

参数方向约束说明
Text输入借用字面量文本
pOutputSize输出非空接收字节数
返回值
返回含义失败时状态
true已写出长度—
false参数非法XERR_ARGUMENT
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 转义查询

	if ( !xrtRegexEscapeSize(SV("a.b*c"), &iSize) ||
		(iSize != 7u) ||
		/* 长度出参必填(与 Escape 的可空不同),容量含末尾零。 */
		!xrtRegexEscapeWrite(SV("a.b*c"), Escape,
			sizeof(Escape), &iSize) ||
		(strcmp(Escape, "a\\.b\\*c") != 0) ) {

xrtRegexEscapeWrite函数

将字面量文本转义到调用方缓冲区;容量必须包含末尾零。

bool xrtRegexEscapeWrite(xstrview Text, char* sOutput, size_t iCapacity, size_t* pOutputSize)

参数

参数方向约束说明
Text输入借用字面量文本
sOutput输出非空输出缓冲
iCapacity输入足够容量,须含末尾零
pOutputSize输出允许空接收长度
返回值
返回含义失败时状态
true已写入并补零—
false容量不足或参数非法XERR_RANGE / XERR_ARGUMENT
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_RANGE — 容量不足,不写半个结果

范例已编译验证

regex_tour · 转义写入

		!xrtRegexEscapeWrite(SV("a.b*c"), Escape,
			sizeof(Escape), &iSize) ||

xrtRegexEscape函数

创建由 xrtFree 释放的零结尾正则字面量,长度输出可以为空。

str xrtRegexEscape(xstrview Text, size_t* pOutputSize)

参数

参数方向约束说明
Text输入借用字面量文本
pOutputSize输出允许空接收长度
返回值
返回含义失败时状态
非空零结尾转义文本,xrtFree 释放—
NULL失败XERR_ARGUMENT / XERR_MEMORY
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

regex · 分配转义

	sLiteral = xrtRegexEscape(XRT_STR_LITERAL("file[1].txt"), &iLiteralSize);

xrtRegexConfigInit函数

初始化默认编译标志和有限资源预算。

void xrtRegexConfigInit(xregexconfig* pConfig)

参数

参数方向约束说明
pConfig输出非空接收配置
返回值
返回含义失败时状态
无已初始化—
错误
  • 无 — 初始化不失败

范例已编译验证

regex_tour · 默认配置

	xrtRegexConfigInit(&Config);

xrtRegexCompile函数

使用默认配置编译明确长度的 UTF-8 正则表达式。

xregex* xrtRegexCompile(xstrview Pattern)

参数

参数方向约束说明
Pattern输入借用表达式
返回值
返回含义失败时状态
非空编译对象(引用 1)—
NULL编译失败xrt.regex 域错误
错误
  • xrt.regex / XREGEX_ERROR_PATTERN(XERR_VALUE / XERR_RANGE) — 表达式语法非法;字节位置可由 xrtRegexErrorOffset 读取
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_tour · 默认编译

	pBad = xrtRegexCompile(SV("a(b"));
	if ( (pBad != NULL) ||
		((pError = xrtTakeError()) == NULL) ||
		!xrtRegexErrorOffset(pError, &iOffset) ||
		(iOffset != 3u) ) {
		goto Cleanup;
	}
	xrtErrorFree(pError);

	/* ---- 转义两段式:先量尺寸再写入 ---- */
	if ( !xrtRegexEscapeSize(SV("a.b*c"), &iSize) ||

xrtRegexCompileConfig函数

使用高级配置编译正则表达式。

xregex* xrtRegexCompileConfig(xstrview Pattern, const xregexconfig* pConfig)

参数

参数方向约束说明
Pattern输入借用表达式
pConfig输入非空编译配置
返回值
返回含义失败时状态
非空编译对象(引用 1)—
NULL编译失败xrt.regex 域错误
错误
  • xrt.regex / XREGEX_ERROR_CONFIG(XERR_ARGUMENT / XERR_VALUE) — 配置字段非法
  • xrt.regex / XREGEX_ERROR_PATTERN(XERR_VALUE / XERR_RANGE) — 表达式语法非法;字节位置可由 xrtRegexErrorOffset 读取
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_tour · 高级编译

	pDate = xrtRegexCompileConfig(SV("(?<year>\\d+)-(?<month>\\d+)"),
		&Config);

xrtRegexValid函数

验证表达式能否使用默认配置完成编译。

bool xrtRegexValid(xstrview Pattern)

参数

参数方向约束说明
Pattern输入借用表达式
返回值
返回含义失败时状态
true可编译—
false不可编译xrt.regex 域错误
错误
  • xrt.regex / XREGEX_ERROR_PATTERN(XERR_VALUE / XERR_RANGE) — 表达式语法非法;字节位置可由 xrtRegexErrorOffset 读取
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算

范例已编译验证

regex_tour · 可编译校验

		!xrtRegexValid(SV("\\d+")) ||

xrtRegexRef函数

增加编译对象引用并返回原指针。

xregex* xrtRegexRef(xregex* pRegex)

参数

参数方向约束说明
pRegex输入非空目标编译对象
返回值
返回含义失败时状态
非空原指针,引用 +1—
NULL参数非法XERR_ARGUMENT
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 共享引用

		(xrtRegexRef(pDate) != pDate) ||

xrtRegexRelease函数

释放编译对象引用。

void xrtRegexRelease(xregex* pRegex)

参数

参数方向约束说明
pRegex输入允许空空 = 空操作
返回值
返回含义失败时状态
无引用 -1—
错误
  • 无 — 释放不失败

范例已编译验证

regex_tour · 释放引用

		xrtRegexRelease(pComma);

xrtRegexPattern函数

返回编译对象持有的原始表达式视图。

xstrview xrtRegexPattern(const xregex* pRegex)

参数

参数方向约束说明
pRegex输入非空目标编译对象
返回值
返回含义失败时状态
视图表达式借用—
空视图参数非法XERR_ARGUMENT
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 原始表达式

		(xrtRegexPattern(pDate).Size == 0u) ||

xrtRegexFlags函数

返回编译时使用的标志。

uint32 xrtRegexFlags(const xregex* pRegex)

参数

参数方向约束说明
pRegex输入非空目标编译对象
返回值
返回含义失败时状态
标志位编译标志—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 编译标志

		(xrtRegexFlags(pDate) != XREGEX_IGNORE_CASE) ||

xrtRegexCaptureCount函数

返回包含组 0 在内的捕获数量。

size_t xrtRegexCaptureCount(const xregex* pRegex)

参数

参数方向约束说明
pRegex输入非空目标编译对象
返回值
返回含义失败时状态
>= 0含组 0 的捕获数量—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 捕获数量

		(xrtRegexCaptureCount(pDate) != 3u) ) {

xrtRegexCaptureName函数

返回指定捕获的借用名称;未命名捕获返回空视图。

bool xrtRegexCaptureName(const xregex* pRegex, size_t iIndex, xstrview* pName)

参数

参数方向约束说明
pRegex输入非空目标编译对象
iIndex输入< 捕获数量捕获索引
pName输出非空接收名称视图
返回值
返回含义失败时状态
true已写出(可为空视图)—
false索引越界XERR_RANGE
错误
  • XERR_RANGE — 捕获索引越界;句柄为空 XERR_ARGUMENT

范例已编译验证

regex_tour · 捕获名称

		if ( !xrtRegexCaptureName(pDate, 1u, &Name) ||
			(Name.Size != 4u) ||
			(memcmp(Name.Data, "year", 4u) != 0) ||
			(xrtRegexCaptureIndex(pDate, SV("year")) != 1u) ||
			(xrtRegexCaptureIndex(pDate, SV("nope")) !=
				XRT_NPOS) ) {

xrtRegexCaptureIndex函数

按名称查找捕获索引,未找到时返回 XRT_NPOS。

size_t xrtRegexCaptureIndex(const xregex* pRegex, xstrview Name)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Name输入借用捕获名称
返回值
返回含义失败时状态
索引命中的捕获索引—
XRT_NPOS未找到不设错误
错误
  • 未找到返回 XRT_NPOS 且不设置错误;句柄为空 XERR_ARGUMENT

范例已编译验证

regex_tour · 按名查找捕获

			(xrtRegexCaptureIndex(pDate, SV("year")) != 1u) ||

xrtRegexErrorOffset函数

从 xrt.regex 错误的机器数据中读取字节位置。

bool xrtRegexErrorOffset(const xerror* pError, size_t* pOffset)

参数

参数方向约束说明
pError输入非空、xrt.regex 域编译/执行错误
pOffset输出非空接收表达式内字节偏移
返回值
返回含义失败时状态
true已写出偏移—
false错误不含位置数据不设错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • 无位置数据时返回 false 且不设置错误

范例已编译验证

regex_tour · 错误定位

		!xrtRegexErrorOffset(pError, &iOffset) ||
集合匹配

xrtRegexMatcherCreate函数

为一个不可变编译对象创建可复用 matcher。

xregexmatcher* xrtRegexMatcherCreate(xregex* pRegex)

参数

参数方向约束说明
pRegex输入非空目标编译对象
返回值
返回含义失败时状态
非空matcher(持有编译对象引用)—
NULL创建失败XERR_ARGUMENT / XERR_MEMORY
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

regex · 创建 matcher

	pMatcher = xrtRegexMatcherCreate(pRegex);

xrtRegexMatcherFree函数

释放 matcher、执行缓存和持有的编译对象引用。

void xrtRegexMatcherFree(xregexmatcher* pMatcher)

参数

参数方向约束说明
pMatcher输入允许空空 = 空操作
返回值
返回含义失败时状态
无已释放—
错误
  • 无 — 释放不失败

范例已编译验证

regex · 释放 matcher

			xrtRegexMatcherFree(pMatcher);

xrtRegexMatcherFind函数

从字节位置开始搜索首个匹配。

xregexresult xrtRegexMatcherFind(xregexmatcher* pMatcher, xstrview Text, size_t iStart)

参数

参数方向约束说明
pMatcher输入/输出非空目标 matcher
Text输入借用输入文本
iStart输入<= Text.Size起始字节偏移
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex · 搜索匹配

	for ( xregexresult Result = xrtRegexMatcherFind(pMatcher, Text, 0);
		 Result == XREGEX_MATCH;
		 Result = xrtRegexMatcherNext(pMatcher) ) {

xrtRegexMatcherAt函数

要求首个匹配恰好从指定字节位置开始。

xregexresult xrtRegexMatcherAt(xregexmatcher* pMatcher, xstrview Text, size_t iStart)

参数

参数方向约束说明
pMatcher输入/输出非空目标 matcher
Text输入借用输入文本
iStart输入<= Text.Size锚定字节偏移
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 锚定匹配

		xrtRegexMatcherAt(pMatcher, SV("2024-05!"), 0u) ==

xrtRegexMatcherFull函数

要求表达式覆盖完整输入。

xregexresult xrtRegexMatcherFull(xregexmatcher* pMatcher, xstrview Text)

参数

参数方向约束说明
pMatcher输入/输出非空目标 matcher
Text输入借用输入文本
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 完整匹配

		xrtRegexMatcherFull(pMatcher, SV("2024-05")) ==

xrtRegexMatcherNext函数

继续查找下一项,空匹配会按一个 UTF-8 标量向前推进。

xregexresult xrtRegexMatcherNext(xregexmatcher* pMatcher)

参数

参数方向约束说明
pMatcher输入/输出非空已持有匹配的 matcher
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex · 继续查找

		 Result = xrtRegexMatcherNext(pMatcher) ) {

xrtRegexMatcherMatched函数

返回 matcher 当前是否持有一次成功匹配。

bool xrtRegexMatcherMatched(const xregexmatcher* pMatcher)

参数

参数方向约束说明
pMatcher输入非空目标 matcher
返回值
返回含义失败时状态
true是持有匹配—
false不是持有匹配—
错误
  • 无 — 纯查询,不设置错误

范例已编译验证

regex_tour · 命中查询

		!xrtRegexMatcherMatched(pMatcher) ||

xrtRegexMatcherText函数

返回当前输入的借用视图。

xstrview xrtRegexMatcherText(const xregexmatcher* pMatcher)

参数

参数方向约束说明
pMatcher输入非空目标 matcher
返回值
返回含义失败时状态
视图当前输入借用—
空视图参数非法XERR_ARGUMENT
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 输入视图

		(xrtRegexMatcherText(pMatcher).Size != 13u) ||

xrtRegexMatcherCapture函数

返回指定捕获的参与状态、绝对字节范围和借用文本。

bool xrtRegexMatcherCapture(const xregexmatcher* pMatcher, size_t iIndex, xregexcapture* pCapture)

参数

参数方向约束说明
pMatcher输入非空目标 matcher
iIndex输入< 捕获数量捕获索引
pCapture输出非空接收捕获描述
返回值
返回含义失败时状态
true已写出(未参与时区间为空)—
false无匹配或索引越界XERR_STATE / XERR_RANGE
错误
  • XERR_STATE — 当前无成功匹配
  • XERR_RANGE — 捕获索引越界
  • XERR_ARGUMENT — 指针为空

范例已编译验证

regex_tour · 按索引捕获

	if ( !xrtRegexMatcherCapture(pMatcher, 0u, &Capture) ) {

xrtRegexMatcherCaptureNamed函数

按名称返回当前捕获。

bool xrtRegexMatcherCaptureNamed(const xregexmatcher* pMatcher, xstrview Name, xregexcapture* pCapture)

参数

参数方向约束说明
pMatcher输入非空目标 matcher
Name输入借用捕获名称
pCapture输出非空接收捕获描述
返回值
返回含义失败时状态
true已写出—
false无匹配、未命名或不存在XERR_STATE 或不设错
错误
  • XERR_STATE — 当前无成功匹配;名称不存在返回 false 且不设置错误

范例已编译验证

regex · 按名捕获

		if ( !xrtRegexMatcherCaptureNamed(pMatcher, XRT_STR_LITERAL("name"), &Name) ||
			 !xrtRegexMatcherCaptureNamed(pMatcher, XRT_STR_LITERAL("value"), &Value) ) {

xrtRegexTest函数

使用临时 matcher 搜索编译表达式。

xregexresult xrtRegexTest(xregex* pRegex, xstrview Text)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 临时搜索

	if ( (xrtRegexTest(pDate, SV("say 2024-05")) !=
			XREGEX_MATCH) ||
		(xrtRegexTest(pDate, SV("no digits")) !=
			XREGEX_NONE) ) {

xrtRegexFullTest函数

使用临时 matcher 检查编译表达式是否覆盖完整输入。

xregexresult xrtRegexFullTest(xregex* pRegex, xstrview Text)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex · 临时完整匹配

	if ( xrtRegexFullTest(pRegex, XRT_STR_LITERAL("file[1].txt")) != XREGEX_MATCH ) {

xrtRegexMatch函数

编译默认表达式并执行一次搜索。

xregexresult xrtRegexMatch(xstrview Pattern, xstrview Text)

参数

参数方向约束说明
Pattern输入借用表达式
Text输入借用输入文本
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • xrt.regex / XREGEX_ERROR_PATTERN(XERR_VALUE / XERR_RANGE) — 表达式语法非法;字节位置可由 xrtRegexErrorOffset 读取
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • XERR_MEMORY — 分配失败
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 一次搜索

	if ( (xrtRegexMatch(SV("\\d+"), SV("abc123")) !=
			XREGEX_MATCH) ||
		(xrtRegexMatch(SV("\\d+"), SV("abc")) != XREGEX_NONE) ||
		(xrtRegexFullMatch(SV("\\d+"), SV("123")) !=
			XREGEX_MATCH) ||
		(xrtRegexFullMatch(SV("\\d+"), SV("a123")) !=
			XREGEX_NONE) ) {

xrtRegexFullMatch函数

编译默认表达式并执行一次完整匹配。

xregexresult xrtRegexFullMatch(xstrview Pattern, xstrview Text)

参数

参数方向约束说明
Pattern输入借用表达式
Text输入借用输入文本
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • xrt.regex / XREGEX_ERROR_PATTERN(XERR_VALUE / XERR_RANGE) — 表达式语法非法;字节位置可由 xrtRegexErrorOffset 读取
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • XERR_MEMORY — 分配失败
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 一次完整匹配

		(xrtRegexFullMatch(SV("\\d+"), SV("123")) !=
			XREGEX_MATCH) ||

xrtRegexReplaceTo函数

按模板替换至构建器,SIZE_MAX 表示不限制替换次数。

bool xrtRegexReplaceTo(xregex* pRegex, xstrview Text, xstrview Replacement, size_t iLimit, xstrbuf* pOutput, size_t* pCount)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
Replacement输入借用替换模板
iLimit输入SIZE_MAX = 全部次数上限
pOutput输出非空字符串构建器
pCount输出允许空接收替换次数
返回值
返回含义失败时状态
true已完成追加—
false失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_REPLACEMENT(XERR_VALUE) — 模板引用了不存在的捕获
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 模板替换至构建器

	if ( !xrtRegexReplaceTo(pDate, SV("2024-01 2025-02"),
			SV("[y]"), 1u, &Output, &iCount) ||
		(iCount != 1u) ||
		(xrtStrBufView(&Output).Size != 11u) ||
		(memcmp(xrtStrBufView(&Output).Data, "[y] 2025-02",
			11u) != 0) ) {

xrtRegexReplaceFuncTo函数

由回调生成每次替换内容,失败时撤销本次调用追加的全部数据。

bool xrtRegexReplaceFuncTo(xregex* pRegex, xstrview Text, size_t iLimit, xregexreplacefn pReplace, ptr pUserData, xstrbuf* pOutput, size_t* pCount)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
iLimit输入SIZE_MAX = 全部次数上限
pReplace输入非空替换回调
pUserData输入任意值回调数据
pOutput输出非空字符串构建器
pCount输出允许空接收替换次数
返回值
返回含义失败时状态
true已完成追加—
false失败,本次追加已撤销xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_CALLBACK — 回调失败
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 回调替换至构建器

		!xrtRegexReplaceFuncTo(pWord, SV("aa bb"),
			SIZE_MAX,
			exampleUpperReplace, &iHits, &Output, &iCount) ||

xrtRegexReplace函数

替换全部匹配并返回零结尾独立字符串。

str xrtRegexReplace(xregex* pRegex, xstrview Text, xstrview Replacement)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
Replacement输入借用替换模板
返回值
返回含义失败时状态
非空零结尾结果,xrtFree 释放—
NULL失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_REPLACEMENT(XERR_VALUE) — 模板引用了不存在的捕获
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_replace · 替换全部

	sResult = xrtRegexReplace(
		pRegex,
		XRT_STR_LITERAL("width=128 height=72"),
		XRT_STR_LITERAL("${name}: $2")
	);

xrtRegexReplaceFirst函数

只替换第一个匹配并返回零结尾独立字符串。

str xrtRegexReplaceFirst(xregex* pRegex, xstrview Text, xstrview Replacement)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
Replacement输入借用替换模板
返回值
返回含义失败时状态
非空零结尾结果,xrtFree 释放—
NULL失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_REPLACEMENT(XERR_VALUE) — 模板引用了不存在的捕获
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_tour · 替换首个

	sResult = xrtRegexReplaceFirst(pDate, SV("2024-01 2025-02"),
		SV("[x]"));

xrtRegexSplitConfigInit函数

初始化不限制分隔次数且保留空字段的拆分配置。

void xrtRegexSplitConfigInit(xregexsplitconfig* pConfig)

参数

参数方向约束说明
pConfig输出非空接收配置
返回值
返回含义失败时状态
无已初始化—
错误
  • 无 — 初始化不失败

范例已编译验证

regex_split · 拆分配置

	xrtRegexSplitConfigInit(&Config);

xrtRegexSplitterCreate函数

创建借用输入的流式正则拆分器。

xregexsplitter* xrtRegexSplitterCreate(xregex* pRegex, xstrview Text, const xregexsplitconfig* pConfig)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
pConfig输入允许空空 = 默认配置
返回值
返回含义失败时状态
非空拆分器(持有编译对象引用)—
NULL创建失败XERR_ARGUMENT / XERR_MEMORY
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_split · 创建拆分器

	pSplitter = xrtRegexSplitterCreate(
		pRegex,
		XRT_STR_LITERAL("alpha, beta; gamma"),
		&Config
	);

xrtRegexSplitterFree函数

释放拆分器、matcher 和持有的正则引用。

void xrtRegexSplitterFree(xregexsplitter* pSplitter)

参数

参数方向约束说明
pSplitter输入允许空空 = 空操作
返回值
返回含义失败时状态
无已释放—
错误
  • 无 — 释放不失败

范例已编译验证

regex_split · 释放拆分器

	xrtRegexSplitterFree(pSplitter);

xrtRegexSplitterNext函数

返回下一字段或捕获,XREGEX_NONE 表示遍历结束。

xregexresult xrtRegexSplitterNext(xregexsplitter* pSplitter, xregexsplitpart* pPart)

参数

参数方向约束说明
pSplitter输入/输出非空目标拆分器
pPart输出非空接收字段视图
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_split · 下一字段

	while ( (Result = xrtRegexSplitterNext(pSplitter, &Part)) == XREGEX_MATCH ) {

xrtRegexSplit函数

使用默认配置拆分并返回一个分配块内的零结尾字段。

xstrlist* xrtRegexSplit(xregex* pRegex, xstrview Text)

参数

参数方向约束说明
pRegex输入非空目标编译对象
Text输入借用输入文本
返回值
返回含义失败时状态
非空字段列表,整体一次 xrtFree 释放—
NULL失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_tour · 分配拆分

			((pParts = xrtRegexSplit(pComma,
				SV("ab,cd,ef"))) == NULL) ) {

xrtRegexSetCreate函数

从已有编译对象创建集合,各模式可以使用不同标志。

xregexset* xrtRegexSetCreate(xregex* const* arrRegex, size_t iCount)

参数

参数方向约束说明
arrRegex输入非空数组编译对象指针数组
iCount输入> 0模式数量
返回值
返回含义失败时状态
非空集合(引用 1)—
NULL创建失败XERR_ARGUMENT / XERR_MEMORY
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_tour · 从编译对象创建集合

	pSet = xrtRegexSetCreate(arrRegex, 2u);

xrtRegexSetCompile函数

使用默认配置批量编译模式并创建集合。

xregexset* xrtRegexSetCompile(const xstrview* arrPattern, size_t iCount)

参数

参数方向约束说明
arrPattern输入非空数组表达式数组
iCount输入> 0模式数量
返回值
返回含义失败时状态
非空集合(引用 1)—
NULL创建失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_PATTERN(XERR_VALUE / XERR_RANGE) — 表达式语法非法;字节位置可由 xrtRegexErrorOffset 读取
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_set · 批量编译集合

	xregexset* pSet = xrtRegexSetCompile(arrPattern, 3u);

xrtRegexSetCompileConfig函数

使用同一高级配置批量编译模式并创建集合。

xregexset* xrtRegexSetCompileConfig(const xstrview* arrPattern, size_t iCount, const xregexconfig* pConfig)

参数

参数方向约束说明
arrPattern输入非空数组表达式数组
iCount输入> 0模式数量
pConfig输入非空编译配置
返回值
返回含义失败时状态
非空集合(引用 1)—
NULL创建失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_CONFIG(XERR_ARGUMENT / XERR_VALUE) — 配置字段非法
  • xrt.regex / XREGEX_ERROR_PATTERN(XERR_VALUE / XERR_RANGE) — 表达式语法非法;字节位置可由 xrtRegexErrorOffset 读取
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_tour · 批量编译集合(高级配置)

		pBroken = xrtRegexSetCompileConfig(Patterns, 2u, &Config);

xrtRegexSetRef函数

增加集合引用并返回原指针。

xregexset* xrtRegexSetRef(xregexset* pSet)

参数

参数方向约束说明
pSet输入非空目标集合
返回值
返回含义失败时状态
非空原指针,引用 +1—
NULL参数非法XERR_ARGUMENT
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 共享引用

		(xrtRegexSetRef(pSet) != pSet) ||

xrtRegexSetRelease函数

释放集合引用。

void xrtRegexSetRelease(xregexset* pSet)

参数

参数方向约束说明
pSet输入允许空空 = 空操作
返回值
返回含义失败时状态
无引用 -1—
错误
  • 无 — 释放不失败

范例已编译验证

regex_set · 释放引用

	xrtRegexSetRelease(pSet);

xrtRegexSetCount函数

返回集合中的模式数量。

size_t xrtRegexSetCount(const xregexset* pSet)

参数

参数方向约束说明
pSet输入非空目标集合
返回值
返回含义失败时状态
>= 0模式数量—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_tour · 模式数量

		(xrtRegexSetCount(pSet) != 2u) ||

xrtRegexSetRegex函数

返回集合借用的指定编译对象。

const xregex* xrtRegexSetRegex(const xregexset* pSet, size_t iIndex)

参数

参数方向约束说明
pSet输入非空目标集合
iIndex输入< 模式数量模式索引
返回值
返回含义失败时状态
非空编译对象借用—
NULL索引越界XERR_RANGE
错误
  • XERR_RANGE — 模式索引越界;句柄为空 XERR_ARGUMENT

范例已编译验证

regex_tour · 成员借用

		(xrtRegexSetRegex(pSet, 1u) != pWord) ||

xrtRegexSetErrorIndex函数

从批量编译错误中读取失败的模式索引。

bool xrtRegexSetErrorIndex(const xerror* pError, size_t* pIndex)

参数

参数方向约束说明
pError输入非空、xrt.regex 域批量编译错误
pIndex输出非空接收失败模式索引
返回值
返回含义失败时状态
true已写出索引—
false错误不含模式索引不设错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • 无模式索引时返回 false 且不设置错误

范例已编译验证

regex_tour · 失败模式定位

			!xrtRegexSetErrorIndex(pError, &iErrorIndex) ||

xrtRegexSetMatcherCreate函数

为不可变集合创建可复用 matcher。

xregexsetmatcher* xrtRegexSetMatcherCreate(xregexset* pSet)

参数

参数方向约束说明
pSet输入非空目标集合
返回值
返回含义失败时状态
非空集合 matcher(持有集合引用)—
NULL创建失败XERR_ARGUMENT / XERR_MEMORY
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

regex_set · 创建集合 matcher

	pMatcher = xrtRegexSetMatcherCreate(pSet);

xrtRegexSetMatcherFree函数

释放集合 matcher 及其命中索引。

void xrtRegexSetMatcherFree(xregexsetmatcher* pMatcher)

参数

参数方向约束说明
pMatcher输入允许空空 = 空操作
返回值
返回含义失败时状态
无已释放—
错误
  • 无 — 释放不失败

范例已编译验证

regex_set · 释放集合 matcher

	xrtRegexSetMatcherFree(pMatcher);

xrtRegexSetMatcherMatch函数

从指定字节位置开始计算所有命中的模式。

xregexresult xrtRegexSetMatcherMatch(xregexsetmatcher* pMatcher, xstrview Text, size_t iStart)

参数

参数方向约束说明
pMatcher输入/输出非空目标集合 matcher
Text输入借用输入文本
iStart输入<= Text.Size起始字节偏移
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_set · 集合匹配

	Result = xrtRegexSetMatcherMatch(
		pMatcher,
		XRT_STR_LITERAL("disk timeout"),
		0
	);

xrtRegexSetMatcherCount函数

返回本轮命中的模式数量。

size_t xrtRegexSetMatcherCount(const xregexsetmatcher* pMatcher)

参数

参数方向约束说明
pMatcher输入非空目标集合 matcher
返回值
返回含义失败时状态
>= 0本轮命中数量—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

regex_set · 命中数量

		for ( size_t i = 0; i < xrtRegexSetMatcherCount(pMatcher); i++ ) {

xrtRegexSetMatcherIndex函数

返回本轮第 iIndex 个命中的模式索引。

size_t xrtRegexSetMatcherIndex(const xregexsetmatcher* pMatcher, size_t iIndex)

参数

参数方向约束说明
pMatcher输入非空目标集合 matcher
iIndex输入< 命中数量序号
返回值
返回含义失败时状态
>= 0命中的模式索引—
XRT_NPOS序号越界不设错误
错误
  • 序号越界返回 XRT_NPOS 且不设置错误;句柄为空 XERR_ARGUMENT

范例已编译验证

regex_set · 命中索引

			printf("matched rule %zu\n", xrtRegexSetMatcherIndex(pMatcher, i));

xrtRegexSetMatcherMatched函数

判断指定模式是否在本轮命中。

bool xrtRegexSetMatcherMatched(const xregexsetmatcher* pMatcher, size_t iPattern)

参数

参数方向约束说明
pMatcher输入非空目标集合 matcher
iPattern输入< 模式数量模式索引
返回值
返回含义失败时状态
true是命中—
false不是命中—
错误
  • 无 — 纯查询,不设置错误

范例已编译验证

regex_tour · 指定模式命中查询

		!xrtRegexSetMatcherMatched(pSetMatcher, 0u) ||

xrtRegexSetMatcherFirst函数

返回本轮最小的命中模式索引,未命中时返回 XRT_NPOS。

size_t xrtRegexSetMatcherFirst(const xregexsetmatcher* pMatcher)

参数

参数方向约束说明
pMatcher输入非空目标集合 matcher
返回值
返回含义失败时状态
>= 0最小命中索引—
XRT_NPOS本轮未命中不设错误
错误
  • 未命中返回 XRT_NPOS 且不设置错误;句柄为空 XERR_ARGUMENT

范例已编译验证

regex_tour · 最小命中索引

		(xrtRegexSetMatcherFirst(pSetMatcher) > 1u) ) {

xrtRegexSetTest函数

使用临时 matcher 检查集合中是否有模式命中。

xregexresult xrtRegexSetTest(xregexset* pSet, xstrview Text)

参数

参数方向约束说明
pSet输入非空目标集合
Text输入借用输入文本
返回值
返回含义失败时状态
XREGEX_MATCH命中—
XREGEX_NONE无匹配或遍历结束不设错误
XREGEX_ERROR参数、配置或预算失败xrt.regex 域错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • xrt.regex / XREGEX_ERROR_LIMIT(XERR_RANGE) — 超出编译或执行预算
  • xrt.regex / XREGEX_ERROR_EXECUTE — 执行失败

范例已编译验证

regex_tour · 临时集合匹配

		(xrtRegexSetTest(pSet, SV("hello 2024-01 world")) !=
			XREGEX_MATCH) ) {

常量索引常量

以下常量在本页所属头文件中定义,语义见公共头注释。

常量说明
XREGEX_CAPTURES_DEFAULT见头文件注释
XREGEX_DOT_ALL见头文件注释
XREGEX_ERROR见头文件注释
XREGEX_ERROR_CALLBACK见头文件注释
XREGEX_ERROR_CONFIG见头文件注释
XREGEX_ERROR_EXECUTE见头文件注释
XREGEX_ERROR_LIMIT见头文件注释
XREGEX_ERROR_PATTERN见头文件注释
XREGEX_ERROR_REPLACEMENT见头文件注释
XREGEX_IGNORE_CASE见头文件注释
XREGEX_MATCH见头文件注释
XREGEX_MULTILINE见头文件注释
XREGEX_NONE见头文件注释
XREGEX_PATTERN_DEFAULT见头文件注释
XREGEX_SPLIT_CAPTURES见头文件注释
XREGEX_SPLIT_SKIP_EMPTY见头文件注释
XREGEX_UNGREEDY见头文件注释