SPARQL 1.2 RL

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

• RDF 1.2 概念与抽象数据模型 [RDF12-CONCEPTS]
• SPARQL 1.2 查询语言 [SPARQL12-QUERY]

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

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

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

# 此框表示规则

# 此框表示输入数据

# 此框表示推断数据

变量

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

表达式

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

数据块

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

三元组模板

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

三元组模式

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

过滤元素

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

三元组模式元素

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

否定元素

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

赋值元素

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

规则元素

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

规则头

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

规则体

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

规则集导入项

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

规则

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

单次运行规则

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

一般规则

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

规则集

规则集由零个或多个规则、 零个或多个数据块 以及零个或多个规则集导入项组成。 已解析 规则集是一个规则集， 其中没有导入项。 已解析规则集通过对另一个规则集 应用导入处理过程来创建。

基础图

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

推理 图

推理图是通过 规则集求值生成的 RDF 图。 它包含通过将规则集应用于 基础图而推断出的、不存在于基础图中的 所有推断三元组。

规则集 求值

规则集求值是将规则集 应用于基础图以生成推理 图的过程。 规则 求值是对规则求值一次的过程。 对规则求值会根据规则体的求值结果，生成规则头给出的所有三元组， 无论某个三元组是位于基础图中、已在规则集求值期间推断出， 还是一个新的推断三元组。 在规则集求值期间，一个规则可能会进行多次 求值。

SPARQL-RL 提供两种操作：infer 和query。

推断

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

查询

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

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

SPARQL-RL 处理器

SPARQL-RL 处理器是实现 SPARQL-RL 规范、能够对规则集求值，并提供以下一种或两种 操作的系统：推断和查询。

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

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

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

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

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

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

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

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

令 V_all 为 V₀ 与所有 vars_j 的并集， 其中 j 为从 1 到 N 的 j，N 为该序列的长度。

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

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

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

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

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

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

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

三元组 模式匹配

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

三元组模式依赖关系

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

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

规则依赖关系

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

闭合依赖

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

• 出现在 R1 的否定元素内的一个三元组模式 与 R2 的规则头中的一个三元组模板匹配。
• 规则 R1 依赖于规则 R2 且 R1 是一个仅运行一次的规则，即 规则 R1 具有一个赋值元素，或者 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(μ, triple pattern)， 它返回一个三元组模式， 其中，对于三元组模式中 位于 dom(μ) 内的每个变量出现位置，都会将其替换为 解映射为 var 给出的RDF 项。 如果生成的三元组模式没有变量，则它是一个 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.
    ## μ is a solution sequence
    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, μ), ..., evalFunction(exprN, μ))
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 ∪︀ 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 语法和语义 一致性的字符串。

版本声明应该在文档前部给出。

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

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

空白符 （产生式 WS）用于 分隔两个原本会被（错误地）识别为一个 终结符的终结符。下面以大写形式书写的规则名称指示空白符 具有重要意义的位置；这些名称构成了用于构建 SPARQL-RL 解析器的一种可能的终结符选择。

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

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

根据 统一资源标识符（URI）：通用 语法 [RFC3986]， 相对 IRI 引用使用基础 IRI 进行解析，并且仅使用第 5.2 节中的 基本算法。 不执行基于语法的规范化或基于方案的规范化 （见 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 相对于前一个基础 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 码点，下表描述了本节中使用的特定 字符。