SHACL 1.2 规则

以下其他规范提供了本文档中使用的基础术语：

• RDF 1.2 Concepts and Abstract Data Model [RDF12-CONCEPTS]
• SPARQL 1.2 Query Language [SPARQL12-QUERY]

本文档中的一些示例使用 RDF 1.2 Turtle [RDF12-TURTLE]。

在本文档中，使用以下命名空间前缀绑定：

在整个文档中，将出现包含 Turtle 格式 RDF 图的彩色编码框。 这些 Turtle 文档片段使用上面给出的前缀绑定。

# This box represents rules

# This box represents input data

# This box represents inferred data

变量

变量表示三元组模式中一个可能的 RDF 项。 变量也用于表达式中。

表达式

表达式是一个函数或函数形式； 其参数是 RDF 项。 表达式相对于一个解映射进行求值，并给出 一个 RDF 项作为结果。 表达式与 SHACL 列表参数函数 以及 SPARQL 表达式兼容。

数据块

数据块是一组三元组。 这些三元组作为附加事实添加到推理图中，并 包含在推理过程中。

三元组模板

三元组模板是一个三元组，其中每个元素或者是 一个变量，或者是一个 RDF 项（它可能是一个三元组项）。 该元组的第二个元素必须是一个 IRI 或一个 变量。 三元组模板出现在规则头中，该规则头属于一个规则。

三元组模式

三元组模式是一个三元组，其中每个元素或者是一个 变量，或者是一个 RDF 项（它可能是一个三元组项）。 该元组的第二个元素必须是一个 IRI 或一个 变量。

过滤器元素

过滤器元素是一个表达式 ，它作为规则元素出现 它用于限制模式匹配中 变量的值。

三元组模式元素

三元组模式元素是一个三元组模式 ，它作为规则元素出现。

否定元素

否定元素是一个规则元素。 它具有一个否定元素体 ，由一系列三元组模式元素和 过滤器元素组成。

赋值元素

赋值元素是一个规则元素，它是 一个由以下两项组成的对： 一个变量，称为赋值变量， 以及一个表达式，称为赋值表达式。

规则元素

一个规则元素是以下任意一种： 三元组模式元素、 过滤器元素、 否定元素，或 赋值元素。

规则头

规则头是一系列三元组 模板。

规则体

规则体是一系列规则元素； 也就是说，序列中的每个元素都是以下之一： 一个三元组模式元素、 一个过滤器元素、 一个否定元素， 或一个赋值元素。

规则集导入

规则集导入（通常简称为“导入”）是一个 URL 集合， 用于指定将在求值期间包含的其他规则集。

规则

规则是一个由规则头（通常简称为 “头”）和 一个规则体（通常简称为“体”）组成的对。 可以为一个规则指定一个 URI，以帮助标识它。

单次运行规则

单次运行规则是在规则集求值过程中的 特定时刻恰好运行一次的规则。

一般规则

一般规则是一个不是单次运行规则的规则。 在规则集求值期间，一般规则可以运行多次。

规则集

规则集是由零个或多个规则组成的集合、 由零个或多个数据块组成的集合， 以及由零个或多个规则集导入组成的集合。 已解析 规则集是一个规则集 ，它不包含任何导入。 已解析规则集通过对另一个规则集 应用导入过程而创建。

基础图

基础图是作为 求值过程输入给出的 RDF 图。

推理 图

推理图是由 规则集求值产生的一个 RDF 图。 它包含所有不在基础图中、并通过将规则集应用于 基础图而推导出的三元组。

规则集 求值

规则集求值是将一个规则集 应用于一个基础图以产生一个推理 图的过程。 规则 求值是对一个规则求值一次的过程。 对规则求值会产生由规则头根据 规则体的求值所给出的所有三元组，无论一个 三元组是否位于基础图中、是否已在规则集求值期间被推导出， 或者是否是一个新推导出的三元组。 在规则集求值期间，一个规则可以被求值 多次。

形状规则语言提供两种操作：推断和查询。

推断

推断是将一个规则集应用于给定的 基础图，并产生一个包含推断 三元组的推断图的操作。它会应用完整的规则集求值。

查询

查询是确定给定的目标 模式能否使用规则集从一个基础图推导出的操作。 它可以不对所有规则进行求值；相反，它可以只对 回答查询目标所必需的规则进行求值。

查询等价于执行一次推断操作， 然后将目标模式与组合后的基础图和 推断图进行匹配。

在三元组模式或三元组 模板中， 元组的位置 1 非正式地称为主语， 位置 2 非正式地称为谓词，而 位置 3 非正式地称为宾语。

以下表示法用于规则集和规则的各种组成部分。

良构性是针对 规则集抽象语法的一组条件。这些条件共同确保 规则变量在 规则的头部中具有在规则主体中定义的值； 过滤器元素 或赋值表达式中的每个变量 在求值时都具有值； 并且规则中的每个 赋值都会引入一个新变量， 即一个此前未在规则主体中使用过的变量。

给定一个初始变量集合，我们为一系列规则元素 定义良构性。

令 elt_i 为一系列规则元素中的第 i 个元素。

令 vars_i 为由 elt_i 定义的变量集合，其中：

令 V₀ 为一个序列的初始变量。

令 V_i 为 V₀ 与所有 vars_j 的并集， 其中 j 小于 i。

令 V_all 为 V_N， 其中 N 是该序列的长度。

给定一个变量集合 V₀，如果满足以下条件，则 良构 序列是一系列规则元素：

如果在 V₀ 为空集的情况下，规则的规则主体序列是一个良构序列， 并且规则头的每个三元组模板中的每个变量 都是 V_all 的元素， 则该规则是一个良构 规则。

当且仅当一个规则集的所有 规则都是良构规则时，该规则集才是一个良构规则集。

如果第二个规则的输出会影响第一个规则主体的求值，则规则 R1 依赖于规则 R2。 也就是说，R2 的头中有一个三元组模板，它可能生成一个与 R1 主体中的三元组模式匹配的三元组， 该三元组模式可以作为三元组模式元素，也可以位于否定元素内部。

有两种依赖关系： 封闭依赖和开放 依赖。 封闭依赖确保规则 R2 在规则 R1 执行之前已经生成其所有可能的输出。 如果规则依赖不是封闭的，则它是开放依赖， 这允许第一个规则 R1 在 规则 R2 可能再次运行以生成更多三元组时执行， 随后这些三元组可使 R1 使用来自 R2 的新三元组重新求值。

在第一个示例中，第一个规则对第二个规则具有开放依赖 关系。

在第二个示例中，第一个规则对第二个规则具有封闭依赖 关系：三元组模式 ?x :status :criticallyExposed 出现在第一个规则的一个否定元素内部，并且 与第二个规则头中的三元组模板匹配。 在第二个规则生成其所有可能的输出之前， 无法对第一个规则进行求值。

三元组 模式匹配

如果一个三元组模板可以生成一个与 一个三元组模式匹配的三元组，则该三元组模式与该三元组模板匹配。

三元组模式依赖

如果一个三元组模式可能与一个三元组模板匹配，则该三元组模式 依赖于一个三元组模板。

如果一个三元组模式依赖于规则 头中的任一三元组模板，则该三元组模式 依赖于一个规则。

规则依赖

如果 R1 主体中的任一 三元组模式，无论是作为三元组模式元素还是 位于否定元素内部， 依赖 于 R2 头中的一个三元组模板，则规则 R1 依赖于 R2。

封闭依赖

如果满足以下任一条件，则规则 R1 对规则 R2 的规则依赖是一个封闭依赖：

• 出现在 R1 的一个否定元素内部的一个三元组模式 与 R2 的规则头中的一个三元组模板匹配。
• 规则 R1 依赖于规则 R2 并且 R1 有一个赋值元素。
• 规则 R1 依赖于规则 R2 并且 R1 的规则头有一个空白节点。

开放依赖

如果规则 R1 对规则 R2 的规则依赖不是 封闭依赖，则它是一个开放依赖。 也就是说，R1 中依赖于 R2 的任何三元组模式都仅作为三元组模式元素出现。

define mergeLabel(oldLabel, newLabel):
    ## 封闭依赖优先于开放依赖。
    if oldLabel == "open" and newLabel == "open":
        return "open"
    else:
        return "closed"
    endif
enddefine

## 输出 -- 具有规则顶点和带标签边的依赖图。
define buildDependencyGraph(ruleSet):
    ## edgeLabelMap 将 (R1, R2) 映射到 "open" 或 "closed"
    let edgeLabelMap be a map from pair (rule, rule) to label

    foreach rule R1 in ruleSet.rules:
        ## 将规则中的每个三元组模式 TP 分类为需要 "open" 或 "closed"
        ## 具体取决于它是否位于否定元素中。
        let bodyDependencies = {}
        foreach rule element RBE in R1.body:
            if RBE is a negation element:
                foreach triple pattern TP in RBE.inner
                    let item be a pair (TP, "closed")
                    add item to bodyDependencies
                endfor
            else if RBE is a triple pattern element of triple pattern TP:
                let item be a pair (TP, "open")
                add item to bodyDependencies
            else if RBE is a condition element:
                ## 不执行任何操作
            else if RBE is an assignment element:
                ## 不执行任何操作
            endif
        endfor

        foreach pair (triple pattern TP, depLabel) in bodyDependencies:
            if R1.body has an assignment element:
              set depLabel to "closed"
            endif
            if R1.head has a triple template with a blank node:
              set depLabel to "closed"
            endif
            ## 查找此三元组模式元素或否定元素的依赖关系。
            foreach rule R2 in ruleSet.rules:
                foreach triple template TT in R2.head:
                    if triple pattern TP matches triple template TT:
                        let key = (R1, R2)
                        if edgeLabelMap contains key:
                            let oldLabel = edgeLabelMap.get(key)
                            let merged = mergeLabel(oldLabel, depLabel)
                            edgeLabelMap.set(key, merged)
                        else:
                            edgeLabelMap.set(key, depLabel)
                        endif
                    endif
                endfor
            endfor
        endfor
    endfor

    let DP = { }
    foreach entry ((R1, R2), label) in edgeLabelMap:
        add an edge (R1 -> R2) labeled with label to DP
    endfor

    the result is DP
    enddefine

分层是将一个规则集 划分为一系列有序分层层级（也称为 “层”，单数为“层”）的过程。较低层中的规则 先于较高层中的规则进行求值。

分层对规则之间的依赖关系施加约束， 以确保否定元素、赋值 元素以及 在规则头中创建的空白节点仅依赖于使用 较早（较低）的层和基础图计算出的结果。 这保证了在给定基础图上对规则集进行求值时，会得到唯一、明确定义且有限的 结果。

分层层级

一个分层层级 SL 是一对 互不相交的规则集合 （SL.once、SL.general）。 SL.once 包含一次性运行规则，即 使用赋值元素或 在规则头中生成 空白节点的规则；这些规则中的每一个都在分层层级开始求值时恰好求值 一次。 SL.general 包含其余规则，这些规则会被反复求值， 直到不再推断出新的三元组。

分层

一个规则集的分层是一系列 分层层级。 一个规则集中的每个规则恰好出现在 其中一个分层层级的一个集合中。

## 输出 -- 映射：整数 -> 规则集合。

define stratification(ruleSet):

    let DP = Dependency graph for the rule set.
    let stratumMap be a map from rule to integer

    ## 依赖图应满足分层条件。
    ## 对无界分层的检查是一项保护措施 
    ## 用于处理违反分层条件的情况。
    let limit = num rules + 1
    let maxStratum = 0

    ## 初始化 stratumMap
    foreach rule in ruleSet.rules:
        stratumMap.set(rule, 0)
        endfor

    boolean changed = true;
    while changed:
        changed = false;
        foreach edge E in DP:
            ## 从 pRule 到 qRule 的带标签边
            let pRule = source of edge
            let qRule = destination of the edge
            let label = edge label

            if label == "open" :
                if stratumMap.get(pRule) < stratumMap.get(qRule) :
                    stratumMap.set(pRule, stratumMap.get(qRule))
                    changed = true;
                endif
            endif
            if label == "closed" :
                if stratumMap.get(pRule) <= stratumMap.get(qRule) :
                    let xStratum = 1 + stratumMap.get(qRule)
                    if ( xStratum > limit )
                        ## 违反分层要求
                        error "Stratification error"
                        endif
                    stratumMap.set(pRule, xStratum)
                    maxStratum = max(maxStratum, xStratum)
                    changed = true;
                endif
            endif
        endfor
    endwhile

    ## 初始化结果映射。
    let stratumRules be a map from integer to rules.
    for i = 0 to maxStratum
        stratumRules.set(i, {})
    endfor

    ## 收集 stratumMap 中具有相同层级编号的规则
    for rule R in map stratumMap:
        let stratumNum = stratumMap.get(R)
        add R to stratumRules.get(stratumNum)
    endfor

    ## 将每个层级划分为 once 和 general
    let stratumLevels be a sequence of pairs of sets of rules.
    for i = 0 to maxStratum:
        let rules = stratumRules.get(i)
        let once = { R in rules | R is a run-once rule }
        let general = rules \ once
        stratumLevels.set(i, pair(once, general))
    endfor

    the result is stratumLevels
enddefine

从 Web 读取文档具有安全方面的影响。 SRL 处理器可以选择是否支持导入规则集。 此外，实现可以提供部分支持， 例如支持导入某些规则集而不支持其他规则集， 并且可能从经过验证的副本导入。

以下条件适用于导入处理：

• 不支持导入规则集的实现必须拒绝 包含 IMPORTS 语句的规则集，并发出错误信号。
• 提供部分支持的实现 必须在遇到其不支持的导入项时发出错误信号。
• 如果实现无法解析导入 文档，或者该文档在语法上无效，则实现必须发出错误信号。
• 在处理 IMPORTS 语句时，为避免无限循环， 处理器必须仅导入一个规则集一次。

已解析规则集通过递归读取另一个规则集的 导入项中提到的所有规则集， 从该规则集生成。

示例算法见A. 示例导入算法。

解映射

一个解映射 μ 是一个偏 函数 μ : V → T， 其中 V 是所有变量的集合， 而 T 是所有 RDF 项的集合。 μ 的定义域表示 为 dom(μ)，它是 V 中 μ 有定义的子集。当明确指的是解映射时，我们使用术语 解。 用 μ₀ 表示满足以下条件的解映射： dom(μ0) 是空集。

替换函数

替换函数，或简称为替换， 是一个函数 subst(μ, 三元组模式) ，它返回一个三元组模式 ，其中三元组模式中每次出现的、位于 dom(μ) 中的变量 都会被RDF 项替换，该 RDF 项由 解映射针对 var 给出。 如果得到的三元组模式不包含变量，那么它就是一个 RDF 三元组。

求值 图

求值图是一个 RDF 图，它将基础图 与规则集求值期间产生的所有三元组合并在一起。

图匹配

图匹配用于找出将 三元组模式映射到 RDF 图中三元组的各种方式。

设 G 为一个 RDF 图，TP 为一个三元组模式。 函数 graphMatch(G, TP) 返回所有可能的 解的集合，这些解 应用于三元组模式时，会产生一个位于 求值图中的三元组

设 G 为一个 RDF 图，TP 为一个三元组模式， 并设 V 为 TP 中出现的变量集合。

graphMatch(G, TP) = { μ | dom(μ) = V and subst(μ, TP) is a triple in G }

解兼容

如果两个解 S1 和 S2 在共有变量上的值一致，则它们是兼容的。

设 S1 和 S2 为解。

compatible(μ1, μ2) = true
                      if forall v in dom(μ1) intersection dom(μ2)
                          μ1(v) = μ2(v)
compatible(μ1, μ2) = false otherwise

解 序列

解序列是解的多重集。 该序列没有定义的顺序。 它等价于一个无序列表，并且可以包含重复项。

解合并

如果两个解兼容，则两个解的合并是这样一个解： 它将每个解中的变量映射到来自其中一个解的 RDF 项。

设 μ₁、μ₂ 为解映射，并设 S1 和 S2 为解序列。

merge(μ1, μ2) = { μ |
                    μ(v) = μ1(v) if v in dom(μ1)
                    μ(v) = μ2(v) otherwise }

merge(S1, S2) = { μ |
                    μ1 in S1, μ2 in S2
                    and compatible(μ1, μ2)
                    μ(v) = merge(μ1, μ2) }

注

merge(S1, S2) 的定义域是 domain(S1) ∪︀ domain(S2)

如果两个解没有共同变量，则它们是兼容的， 并且两个解的合并是 S1 和 S2 的并集。

有效布尔值

函数 EBV(x) 返回一个 RDF 项的有效布尔值。

规则集的求值涉及收集所有导入的规则集， 并按照 4.5 处理 导入中的描述构建单个合并规则集。

然后按照以下步骤准备合并后的规则集 以进行求值。

1. 按照 4.2 良构性 条件中的描述，检查每条规则是否为良构规则。
2. 按照 4.3.2 依赖图算法中的描述，计算依赖图。
3. 按照 4.4.2 分层算法）中的描述，计算合并规则集的分层。

表达式无论是用于过滤元素还是 赋值元素，都会相对于一个 解映射求值；该解映射为表达式中的每个变量提供一个 RDF 术语值。 4.2 良构性条件 中的良构性要求确保表达式中的所有变量 都出现在解映射中。

define evalFunction(F, μ):
    ## F is an expression: an RDF term, a variable, or op(expr1, ..., exprN)
    ## where op is a function or a functional form.
    if F is an RDF term:
        return F
    if F is a variable:
        ## By well-formedness, F ∈ dom(μ).
        return μ(F)
    ## F is of the form F= op(expr1, ..., exprN)
    if op is a functional form (e.g. IF, logical-or):
        ## Evaluated specifically for op; op may evaluate only some arguments.
        ## For example, IF(c, t, f) evaluates c, then exactly one of t or f.
        return the value defined for op over expr1, ..., exprN under μ
    ## op is an ordinary function: evaluate all arguments first.
    return F(evalFunction(expr1, row), ..., evalFunction(exprN, row))
enddefine

一个规则通过从规则主体计算一个解 序列来求值， 然后使用该解序列中的每个解映射， 使用规则头生成三元组。

三元组模式中的空白节点表现得像变量。 这与 SPARQL 图模式匹配兼容。

# Evaluate rule body
# This function returns a sequence of solutions

define evalRuleElements(B, SEQ, G, GD):
    where 
        B is a sequence of rule elements
        SEQ is a solution sequence 
        G and GD are RDF graphs

    for each rule element rElt in B:

        if rElt is a triple pattern TP:
            X = graphMatch(G, TP)
            SEQ1 = {}
            for each μ1 in X:
                for each μ2 in SEQ:
                    if compatible(μ1, μ2)
                      μ3 = merge(μ1, μ2)
                      add μ3 to SEQ1
                    endif
                endfor
            endfor
        endif

        if rElt is a condition element F:
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(F.expr, μ)
                if EBV(x) is true:
                    add μ to SEQ1
                endif
            endfor
        endif

        if rElt is a negation expression N:
            SEQ1 = {}
            for each solution μ in SEQ:
                S = sequence{ μ }
                if rElt with DATA:
                    NEG = evalRuleElements(N.inner, S, GD, GD)
                else:
                    NEG = evalRuleElements(N.inner, S, G, GD)
                if NEG is empty
                    add μ to SEQ1
                endif
            endfor
        endif

        if rElt is an assignment A:
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(A.expr, μ)
                if x is not an error:
                    ## Add mapping V -> x to solution μ
                    let μ2 be a solution mapping μ ∪︀ { (A.var, x) }
                    add μ2 to SEQ1
                else
                    # Error: drop solution μ
                endif
            endfor
        endif

        SEQ = SEQ1
    endfor

    return SEQ
enddefine

define evalRule(R, G, GD):
    where 
        R is a well-formed rule
        G and GD are RDF graphs
    let B be R.body 
        where each blank node in a triple pattern in R.body
        is replaced by a variable which is not used in the rule. 
        The same variable is used for each occurrence of the
        same blank node, and a different variable is used for 
       each different blank node.

    # Solution sequence of one solution that does not map any variables.
    let SEQ0: Solution sequence = { μ0 }

    if R.data:
        let SEQ = evalRuleElements(B, SEQ0, GD, GD)
    else
        let SEQ = evalRuleElements(B, SEQ0, G, GD)
    
    # Evaluate rule head
    let OUT = empty set
    for each μ in SEQ:
        let S = {}
        for each triple template TT in R.head:
            let triple = subst(μ, TT)
            Add triple to S
        endfor
        OUT = OUT union S
    endfor
    return OUT
enddefine

规则集的求值被定义为执行该规则集的 分层中的每个层，其中每一层都按顺序 完整执行，然后再转到下一个层。 对一个层进行求值时，首先对 该层中的每条单次运行规则进行求值，然后重复对 该层中的一般规则进行求值，直至不再产生新的三元组。

let G0 be the input base graph
let RS be the rule set
let D be the graph of all DATA triples in RS

Apply stratification to RS

let LS be the sequence of layers after stratification

# Inference graph
let GI = { t ∈ D | t ∉ G0 }

let GD = G0 ∪︀ D

# Evaluation graph.
let GE = GD

for each stratum ST in LS:
    for each rule R in ST.once:
        let X = evalRule(R, GE, G0)
        let Y = { t ∈ X | t ∉ GE }
        GI = GI ∪︀ Y
        GE = GE ∪︀ Y
    endfor

    let finished = false
    while !finished:
        finished = true
        for each rule R in ST.general:
            let X = evalRule(R, GE, G0)
            let Y = { t ∈ X | t ∉ GE }
            if Y is not empty:
                finished = false
                GI = GI ∪︀ Y
                GE = GE ∪︀ Y
            endif
        endfor
    endwhile
endfor
the result is GI

版本标签是一个字符串，用于标识形状规则语言的语法和语义 一致性 版本。

版本声明应该在文档的较前位置给出。

一个SPARQL-RL 文档中 可以出现多个VERSION指令。 每个指令适用于该指令之后的文档部分， 直到遇到另一个指令或到达文档末尾。

版本标签也可以由 媒体类型的 version 参数给出。在当前不存在 VERSION 指令的情况下，将考虑 作为媒体类型一部分指定的版本。

空白 （产生式 WS）用于 分隔两个终结符，否则它们会被（错误地）识别为一个 终结符。下方以大写字母表示的规则名称指示空白 具有重要意义的位置；这些规则构成了用于构建 形状规则语言解析器的一种可能的终结符选择。

空白在产生式 String 中具有重要意义。

注释以位于 IRIREF、 STRING_LITERAL1、 STRING_LITERAL2、 STRING_LITERAL_LONG1 或 STRING_LITERAL_LONG2 之外的#开始， 并持续到行尾（由 LF 或 CR 标记）， 如果注释标记之后没有行尾，则持续到文件末尾。 注释被视为空白。

相对 IRI 引用按照 统一资源标识符（URI）：通用 语法 [RFC3986]，仅使用 第 5.2 节中的基本算法，基于基础 IRI 进行解析。 不执行基于语法的规范化，也不执行基于方案的规范化 （在 RFC3986 第 6.2.2 和 6.2.3 节中描述）。 根据 国际化资源标识符 （IRI） [RFC3987] 第 6.5 节， IRI 引用中额外允许的字符按照 URI 引用中 非保留字符的相同方式处理。

BASE 指令定义用于按照 [RFC3986] 解析相对 IRI 引用的基础 IRI， 即第 5.1.1 节“嵌入内容中的基础 URI” 。 第 5.1.2 节“来自 封装实体的基础 URI” 定义了作用域内基础 IRI 如何来自封装文档， 例如具有 xml:base 指令的 SOAP 信封，或具有 Content-Location 标头的 MIME 多部分文档。 第 5.1.3 节“来自检索 URI 的基础 URI”中标识的“检索 URI”， 是特定SPARQL-RL 文档被检索时所使用的 URL。 如果上述内容均未指定基础 URI，则使用默认 基础 URI（第 5.1.4 节“默认基础 URI”）。 每个 BASE 指令都会相对于前一个作用域内基础 URI 设置一个新的作用域内基础 URI。

SRL 文档中使用三种形式的转义：

• 数值转义序列表示 Unicode 码点的值。

  数值转义序列不得产生位于 U+D800 到 U+DFFF 范围内的码点值， 该范围是 Unicode 代理码点的范围。

  转义序列	Unicode 码点
  \u hex hex hex hex	位于 U+0000 到 U+D7FF 以及 U+E000 到 U+FFFF 范围内的Unicode 码点， 与四个十六进制数字从最高有效位到最低有效位进行解释后所编码的值相对应。
  \U hex hex hex hex hex hex hex hex	位于 U+0000 到 U+D7FF 以及 U+E000 到 U+10FFFF 范围内的Unicode 码点， 与八个十六进制数字 从最高有效位到最低有效位进行解释后所编码的值相对应。

  其中 hex 是十六进制字符

  HEX ::= [0-9] | [A-F] | [a-f]

• 字符串转义序列表示传统上 在字符串字面量中进行转义的字符：

  转义序列	Unicode 码点
  \t	U+0009
  \b	U+0008
  \n	U+000A
  \r	U+000D
  \f	U+000C
  \"	U+0022
  \'	U+0027
  \\	U+005C

• 保留字符转义序列由一个 \ 后跟 这些字符之一 ~.-!$&'()*+,;=/?#@%_ 构成，并 表示位于 \右侧的字符。

此处使用的 EBNF 定义于 XML 1.0 [EBNF-NOTATION]。

此语法的文本版本可在 此处获取。

本文档使用了一些特定的终结符字面量字符串 [EBNF-NOTATION]。为了明确这些 终结符字面量字符串所使用的 Unicode 码点，下表描述了本节中使用的特定 字符。