Mercurial > emacs
comparison etc/schema/locate.rnc @ 86361:38f93f3d00a2
Initial merge of nxml
author | Mark A. Hershberger <mah@everybody.org> |
---|---|
date | Fri, 23 Nov 2007 06:58:00 +0000 |
parents | |
children | fe571ea62851 |
comparison
equal
deleted
inserted
replaced
86360:aa83d83c27fe | 86361:38f93f3d00a2 |
---|---|
1 default namespace this = "http://thaiopensource.com/ns/locating-rules/1.0" | |
2 namespace local = "" | |
3 | |
4 start = locatingRules | |
5 | |
6 locatingRules = element locatingRules { common, rule* } | |
7 | |
8 rule = | |
9 \include | |
10 # | group | |
11 | applyFollowingRules | |
12 | documentElement | |
13 # | doctypePublicId | |
14 | \namespace | |
15 | uri | |
16 | transformURI | |
17 # | typeIdProcessingInstruction | |
18 | \default | |
19 | typeId | |
20 # | typeIdBase | |
21 | extensionRule | |
22 | |
23 ## Group of rules. Useful with xml:base. | |
24 group = element group { common, rule* } | |
25 | |
26 \include = | |
27 element include { | |
28 common, | |
29 attribute rules { xsd:anyURI } | |
30 } | |
31 | |
32 applyFollowingRules = | |
33 element applyFollowingRules { | |
34 common, | |
35 attribute ruleType { | |
36 "documentElement" | |
37 | "doctypePublicId" | |
38 | "namespace" | |
39 | "uri" | |
40 | "transformURI" | |
41 | "typeIdProcessingInstruction" | |
42 | "default" | |
43 } | |
44 } | |
45 | |
46 documentElement = | |
47 ## Matches if the prefix and/or local name of document element | |
48 ## match the values of the prefix and localName attributes. | |
49 element documentElement { | |
50 common, | |
51 nameAtts, | |
52 targetAtt | |
53 } | |
54 | |
55 ## If there's no prefix attribute, then only the local name must match. | |
56 ## If there's no local name attribute, then only the prefix must match. | |
57 nameAtts = (prefixAtt, localNameAtt?) | localNameAtt | |
58 | |
59 ## prefix="" matches if the document element has no prefix. | |
60 prefixAtt = attribute prefix { (xsd:NCName - "xmlns") | "" } | |
61 localNameAtt = attribute localName { xsd:NCName - "xmlns" } | |
62 | |
63 doctypePublicId = | |
64 ## Matches if the document has a DOCTYPE declaration with a public | |
65 ## identifier that, after normalization, matches the value of the | |
66 ## publicId attribute. | |
67 element doctypePublicId { | |
68 common, | |
69 attribute publicId { publicIdValue }, | |
70 targetAtt | |
71 } | |
72 | |
73 publicIdValue = | |
74 xsd:token { | |
75 ## Newline and tab are excluded, because pattern applies to | |
76 ## the post-normalization value. | |
77 pattern = "[\-'()+,./:=?;!*#@$_%a-zA-Z0-9 ]*" | |
78 } | |
79 | |
80 # This is separate from documentElement so it can be distinguished | |
81 # by applyFollowingRules. | |
82 \namespace = | |
83 ## Matches if the document element has a namespace URI equal to the value | |
84 ## of the ns attribute. A document element with no namespace matches if | |
85 ## the value of the ns attribute is the empty string. | |
86 element namespace { | |
87 common, | |
88 attribute ns { xsd:string }, | |
89 targetAtt | |
90 } | |
91 | |
92 uri = | |
93 ## Matches based on the URI of the document. | |
94 element uri { | |
95 common, | |
96 (resourceAtt | patternAtt), | |
97 targetAtt | |
98 } | |
99 | |
100 ## Matches if it can be determined that the document resource is | |
101 ## the same resource as that identified by the value of the resource | |
102 ## attribute. In determining this, the implementation should apply | |
103 ## the semantics of the URI scheme used by the URI. | |
104 resourceAtt = attribute resource { xsd:anyURI } | |
105 | |
106 ## Matches if the document's URI matches the pattern specified | |
107 ## by the pattern attribute. A * in the path component matches | |
108 ## zero or more characters other than / (after resolving escapes). | |
109 ## If the pattern is a relative URI, it means that there must | |
110 ## be some URI such that when the pattern is resolved relative | |
111 ## to that URI, it matches the document's URI. Thus an empty | |
112 ## pattern will always match. | |
113 patternAtt = attribute pattern { uriPattern } | |
114 | |
115 ## A pattern for a URI. Same syntax as a URI, except that a * in | |
116 ## the path component has a special meaning. | |
117 uriPattern = xsd:anyURI | |
118 | |
119 transformURI = | |
120 ## Generates a URI for the related resource by transforming | |
121 ## the URI of the document. Matches if the transformation | |
122 ## yields a valid URI that identifies an existing resource. | |
123 element transformURI { | |
124 common, | |
125 ## Semantics are the same as the pattern attribute of the uri element. | |
126 attribute fromPattern { uriPattern }, | |
127 ## The result of the transformation is produced from the toPattern | |
128 ## by replacing each * by the string that matched the corresponding | |
129 ## * in the toPattern. The toPattern is appended to the initial | |
130 ## part of the document's URI that was not explicitly matched | |
131 ## by fromPattern. | |
132 attribute toPattern { uriPattern } | |
133 } | |
134 | |
135 \default = | |
136 ## Always matches. | |
137 element default { | |
138 common, | |
139 targetAtt | |
140 } | |
141 | |
142 ## A document can be mapped onto a URI either indirectly via a typeId | |
143 ## or directly. | |
144 targetAtt = uriAtt | typeIdAtt | |
145 | |
146 ## Specifies the URI of the related resource. | |
147 ## xml:base is used if it's relative. | |
148 uriAtt = attribute uri { xsd:anyURI } | |
149 | |
150 ## Specifies an identifier of the type of document. typeId and | |
151 ## typeIdBase rules will be used to map this to a URI. | |
152 typeIdAtt = attribute typeId { typeIdValue } | |
153 | |
154 ## A type identifier can be anything convenient (e.g. a public identifier, | |
155 ## a URL or just a string with no formal structure). Whitespace is | |
156 ## normalized like a public identifier before comparing type identifiers | |
157 ## for equality. | |
158 typeIdValue = xsd:token | |
159 | |
160 typeIdProcessingInstruction = | |
161 ## Matches if there's a processing instruction in the prolog | |
162 ## before any DOCTYPE declaration whose target is the value of | |
163 ## the target attribute. The value of the processing instruction | |
164 ## is interpreted as a typeId, which will be mapped to a | |
165 ## URI as normal. | |
166 element typeIdProcessingInstruction { | |
167 common, | |
168 attribute target { xsd:NCName } | |
169 } | |
170 | |
171 typeId = | |
172 ## Maps a typeId onto a URI. | |
173 element typeId { | |
174 common, | |
175 attribute id { typeIdValue }, | |
176 targetAtt | |
177 } | |
178 | |
179 typeIdBase = | |
180 ## Used to map a typeId onto a URI. First, any URI reserved characters | |
181 ## are URI encoded. If the append attribute is specified, it is appended. | |
182 ## This is then treated as a URI. If relative, it is resolved using | |
183 ## the applicable base URI as usual. If the resulting URI identifies | |
184 ## an existing resource, then the typeId is mapped to this resource. | |
185 ## This is intended to be useful with file URIs. | |
186 element typeIdBase { | |
187 common, | |
188 attribute append { xsd:string }? | |
189 } | |
190 | |
191 extensionRule = | |
192 element * - this:* { | |
193 attribute * { text }*, (text|anyElement)* | |
194 } | |
195 | |
196 anyElement = element * { attribute * { text }*, (text|anyElement)* } | |
197 | |
198 common = | |
199 # attribute xml:base { xsd:anyURI }?, | |
200 attribute * - (xml:base|this:*|local:*) { text }* |