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

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

版本声明 SHOULD 在文档的早期给出。

一个形状 规则语言文档中可以出现多个版本指令。 每个指令适用于其后的文档部分， 直到遇到另一个指令或到达文档末尾。

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

变量

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

表达式

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

数据块

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

三元组模板

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

三元组 模式

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

过滤元素

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

三元组模式元素

三元组模式元素是作为规则元素出现的三元组模式。

否定元素

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

赋值元素

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

规则元素

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

规则头部

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

规则主体

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

规则导入

规则导入（通常简称为“导入”）是一组 URL， 这些 URL 指向将在求值期间被包含的其他规则集。

规则

规则是一对元素：一个规则头部（通常简称为 “头部”）和 一个规则主体（通常简称为“主体”）。 规则可以被赋予一个 URI 以帮助识别它。

只运行一次规则

只运行一次规则是在规则集求值中的某个特定点 恰好运行一次的规则。

一般规则

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

规则集

规则集是零个或多个规则的集合、 零个或多个数据块的集合， 以及零个或多个规则导入的集合。 已解析 规则集是一个没有导入项的规则集。 已解析规则集通过将规则集 应用导入过程来从另一个规则集创建。

基础图

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

推理 图

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

Infer

Infer 是将规则集应用于给定 基础图，并产生包含推理 三元组的推理 图的操作。

Query

Query 是确定某个给定目标 模式是否可以使用 规则集从基础图派生出来的操作。

在三元组模式或三元组 模板中， 元组的位置 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 仍可能 再次运行以生成更多三元组时执行， 这些来自 R2 的新三元组随后可导致 R1 重新求值。

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

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

三元组 模式匹配

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

三元组模式依赖

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

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

规则依赖

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

封闭依赖

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

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

开放依赖

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

define mergeLabel(oldLabel, newLabel):
    ## Closed dependency overrides open dependency.
    if oldLabel == "open" and newLabel == "open":
        return "open"
    else:
        return "closed"
    endif
enddefine

## output -- Dependency graph with rule vertices and labeled edges.
define buildDependencyGraph(ruleSet):
    ## edgeLabelMap maps (R1, R2) to "open" or "closed"
    let edgeLabelMap be a map from pair (rule, rule) to label

    foreach rule R1 in ruleSet:
        ## Classify each triple pattern TP in the rule as requiring "open" or "closed"
        ## depending on whether it is in a negation element or not.
        let bodyDependencies = {}
        foreach rule element RBE in the body of R1:
            if RBE is a negation element:
                foreach triple pattern TP in RBE:
                    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:
                ## Do nothing
            else if RBE is an assignment element:
                ## Do nothing
            endif
        endfor

        foreach pair (triple pattern TP, depLabel) in bodyDependencies:
            if R1 has an assignment element:
              set depLabel to "closed"
            endif
            if R1 has a triple template with a blank node:
              set depLabel to "closed"
            endif
            ## Find depenencies for this triple pattern element or negation element.
            foreach rule R2 in ruleSet:
                foreach triple template TT in head of R2:
                    ## "possibly generate" / matching is defined in
                    ## section 3.3 
                    if TT can possibly match triple pattern TP:
                        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 edge (R1 -> R2) labeled label to DP
    endfor

    the result is DP
    enddefine

示例：

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

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

分层层级

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

分层

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

## output -- Map: Integer -> Set of rules.

define stratification(ruleSet):

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

    ## The dependency graph should satisfy the stratification condition.
    ## The check for unbounded stratification is a guard 
    ## due to a violation of the stratification condition.
    let limit = num rules + 1
    let maxStratum = 0

    ## initialize stratumMap
    foreach rule in ruleSet:
        stratumMap.set(rule, 0)
        endfor

    boolean changed = true;
    while changed:
        changed = false;
        foreach edge E in DP:
            ## Edge from pRule to qRule with a label
            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 )
                        ## Stratification requirement violated
                        error "Stratification error"
                        endif
                    stratumMap.set(pRule, xStratum)
                    maxStratum = max(maxStratum, xStratum)
                    changed = true;
                endif
            endif
        endfor
    endwhile

    ## Initialize the result map.
    let stratumRules be a map from integer to rules.
    for i = 0 to maxStratum
        stratumRules.set(i, {})
    endfor

    ## Gather rules in stratumMap with the same level number
    for rule R in map stratumMap:
        let stratumNum = stratumMap.get(R)
        add R to stratumRules.get(stratumNum)
    endfor

    ## Partition each level into once and 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

语法如下所示。

词汇表：rdf-syntax-vocab.ttl
SHACL 形状：rdf-syntax-shapes.ttl

@@ 插图：文本和 RDF 语法中的 SHACL 规则集：全部特性：

PREFIX :        <http://example/>

DATA { :s :p :o }
RULE { ?x :q :o } WHERE { ?x :p :o }
RULE { ?x :q :o } WHERE { ?x :p :o1 ; :p :o2 }
RULE { ?x :q :o } WHERE { ?x :p ?o . FILTER (?o < 18) }
RULE { ?x :q ?o } WHERE { ?x :p :o . SET (?o := 18) }
RULE { ?x :q ?o } WHERE { ?x :p :o . NOT { ?s :p ?o . FILTER(?o < 18) } }

PREFIX :       <http://example/>
PREFIX rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX sh:     <http://www.w3.org/ns/shacl#>
PREFIX sparql: <http://www.w3.org/ns/sparql#>
PREFIX srl:    <http://www.w3.org/ns/shacl-rules#>

:ruleSet-1
  rdf:type srl:RuleSet;
  srl:data (
    [ srl:subject :s ; srl:predicate :p; srl:object :o ; ]
  );
  srl:rules (
    [
      rdf:type srl:Rule;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o ; ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object :o ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o1 ; ]
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o2 ; ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object :o ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object [ srl:varName "o" ] ; ]
        [
          srl:filter [
            sparql:less-than (
              [ srl:varName "o" ]
              18
            )
          ]
        ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object :o ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o ; ]
        [
          srl:assign [
            srl:assignValue 18 ;
            srl:assignVar [ srl:varName "o" ]
          ]
        ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object [ srl:varName "o" ] ; ]
      )
    ]
    [
      rdf:type srl:Rule ;
      srl:body (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :p ; srl:object :o ; ]
        [
          srl:not (
            [ srl:subject [ srl:varName "s" ] ;     srl:predicate :p ;     srl:object [ srl:varName "o" ] ; ]
            [
              srl:filter [
                sparql:less-than (
                  [ srl:varName "o" ]
                  18
                )
              ]
            ]
          )
        ]
      ) ;
      srl:head (
        [ srl:subject [ srl:varName "x" ] ; srl:predicate :q ; srl:object [ srl:varName "o" ] ; ]
      )
    ]
  ) .

解映射

一个解映射 μ 是一个偏函数 μ : V → T， 其中 V 是所有变量的集合， T 是所有 RDF 术语的集合。 μ 的定义域记作 dom(μ)，它是 V 中 μ 有定义的子集。在明确表示 解映射时，我们使用术语 解。 将 μ₀ 写作这样的解映射： dom(μ0) 是空集合。

替换函数

替换函数，或简称为替换， 是一个函数 subst(μ, 三元组模式)， 它返回一个三元组模式， 其中三元组模式中每个属于 dom(μ) 的变量出现处，都被该 var 的 解映射给出的 RDF 术语替换。 如果所得三元组模式没有变量，那么它就是一个 RDF 三元组。

求值 图

求值图是一个 RDF 图，它组合了 基础图 以及规则集求值期间产生的所有三元组。

图匹配

图匹配查找将三元组模式映射到 RDF 图中三元组的方式。

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

令 G 为一个 RDF 图，TP 为一个 三元组模式。

graphMatch(G, TP) = { μ | 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) }

编辑者注

说明定义域是 dom(S1) ∪︀ dom(S2)。

说明两个没有共有变量的解是兼容的。

对规则集求值的第一步，是准备一个单一的、 有效的规则集。这包括收集所有被导入的规则集， 构建一个单一的组合规则集，然后为该组合规则集计算 分层。

MR.rules = RS1.rules ∪︀ RS2.rules
MR.data = merge(RS1.data, RS2.data)
MR.imports = {}

define imports(rule set RS, set of URLs V), returning rule set
    let I = the set of import URLs declared for the rule set RS
    let RS2 be a rule set formed from RS.rules and RS.data
    foreach URL x in I:
        if x ∉ V:
            V = V ∪︀ { x }
            read rule set RS3 from URL x
            RS2 = rulesetMerge(RS2, imports(RS3, V))
        endif
    endfor
    result is RS2
enddefine

let RS be a rule set
let V = {}
if RS has a location, V = { location of RS }
result is imports(RS, V)

表达式无论是用于过滤元素还是 赋值元素，都会相对于一个 解映射求值；该解映射为表达式中的每个变量提供一个 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

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

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

let R be a well-formed rule.

let rule R = (H, B) where
             H is the sequence of triple templates in the head
             B is the sequence of triple pattern elements,
                condition elements, negation elements,
                and assignment elements in the body

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

let G = evaluation graph

# Evaluate rule body
# This function returns a sequence of solutions
define evalRuleElements(B, SEQ, G):

    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 with expression F:
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(F, μ)
                if EBV(x) is true:
                    add μ to SEQ1
                endif
            endfor
        endif

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

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

        if SEQ1 is empty
            SEQ = {}
            return SEQ
        endif

        SEQ = SEQ1
    endfor

    return SEQ
enddefine

let SEQ = evalRuleElements(B, SEQ0, G)

# Evaluate rule head
let OUT = empty set
for each μ in SEQ:
    let S = {}
    for each triple template TT in H:
        let triple = subst(μ, TT)
        Add triple to S
    endfor
    OUT = OUT union S
endfor

result eval(R, G) is OUT

注意，OUT 可能包含数据图中已有的三元组。

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

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 }

# Evaluation graph.
let GE = G0 ∪︀ D

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

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

空白 （产生式 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 引用中额外允许的字符，按 国际化资源标识符 （IRI） [RFC3987] 第 6.5 节所述，以与 URI 引用中未保留字符相同的方式处理。

BASE 指令定义用于解析 相对 IRI 引用的基准 IRI，依据 [RFC3986] 第 5.1.1 节，“内容中嵌入的基准 URI”。 第 5.1.2 节，“来自封装实体的基准 URI” 定义作用域内基准 IRI 如何来自封装文档， 例如带有 xml:base 指令的 SOAP 信封，或带有 Content-Location 标头的 MIME multipart 文档。 5.1.3，来自检索 URI 的基准 URI中标识的“检索 URI”， 是特定形状规则语言文档 被检索自的 URL。 如果以上均未指定基准 URI，则使用默认 基准 URI（第 5.1.4 节，“默认基准 URI”）。 每个 BASE 指令都会相对于前一个基准 URI 设置新的作用域内基准 URI。

形状规则文档中使用三种形式的转义：

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

  数字转义序列 MUST NOT 产生 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 码点， 下表描述了本节中使用的特定字符。