Annotation of embedaddon/libxml2/test/relaxng/spec_0.xml, revision 1.1.1.1
1.1 misho 1: <?xml version="1.0" encoding="iso-8859-1"?>
2: <!DOCTYPE article [
3: <!-- ELEMENT declarations work around MSXML bug. -->
4: <!ELEMENT section ANY>
5: <!ATTLIST section id ID #IMPLIED>
6: <!ELEMENT appendix ANY>
7: <!ATTLIST appendix id ID #IMPLIED>
8: <!ELEMENT bibliomixed ANY>
9: <!ATTLIST bibliomixed id ID #IMPLIED>
10: ]>
11: <article status="Committee Specification" xmlns:p="http://relaxng.org/ns/proofsystem">
12:
13: <articleinfo>
14: <releaseinfo>$Id: spec.xml,v 1.159 2001/12/02 12:12:12 jjc Exp $</releaseinfo>
15: <title>RELAX NG Specification</title>
16: <authorgroup>
17: <editor>
18: <firstname>James</firstname><surname>Clark</surname>
19: <affiliation>
20: <address><email>jjc@jclark.com</email></address>
21: </affiliation>
22: </editor>
23: <editor>
24: <surname>MURATA</surname><firstname>Makoto</firstname>
25: <affiliation>
26: <address><email>EB2M-MRT@asahi-net.or.jp</email></address>
27: </affiliation>
28: </editor>
29: </authorgroup>
30: <pubdate>3 December 2001</pubdate>
31: <releaseinfo role="meta">
32: $Id: spec.xml,v 1.159 2001/12/02 12:12:12 jjc Exp $
33: </releaseinfo>
34:
35: <copyright><year>2001</year><holder>OASIS</holder></copyright>
36:
37: <legalnotice>
38:
39: <para>Copyright © The Organization for the Advancement of
40: Structured Information Standards [OASIS] 2001. All Rights
41: Reserved.</para>
42:
43: <para>This document and translations of it may be copied and furnished
44: to others, and derivative works that comment on or otherwise explain
45: it or assist in its implementation may be prepared, copied, published
46: and distributed, in whole or in part, without restriction of any kind,
47: provided that the above copyright notice and this paragraph are
48: included on all such copies and derivative works. However, this
49: document itself may not be modified in any way, such as by removing
50: the copyright notice or references to OASIS, except as needed for the
51: purpose of developing OASIS specifications, in which case the
52: procedures for copyrights defined in the OASIS Intellectual Property
53: Rights document must be followed, or as required to translate it into
54: languages other than English.</para>
55:
56: <para>The limited permissions granted above are perpetual and will not
57: be revoked by OASIS or its successors or assigns.</para>
58:
59: <para>This document and the information contained herein is provided
60: on an <quote>AS IS</quote> basis and OASIS DISCLAIMS ALL WARRANTIES,
61: EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE
62: USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY
63: IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
64: PURPOSE.</para>
65:
66: </legalnotice>
67:
68: <legalnotice role="status"><title>Status of this Document</title>
69:
70: <para>This Committee Specification was approved for publication by the
71: OASIS RELAX NG technical committee. It is a stable document which
72: represents the consensus of the committee. Comments on this document
73: may be sent to <ulink
74: url="mailto:relax-ng-comment@lists.oasis-open.org"
75: >relax-ng-comment@lists.oasis-open.org</ulink>.</para>
76:
77: <para>A list of known errors in this document is available at <ulink
78: url="http://www.oasis-open.org/committees/relax-ng/spec-20011203-errata.html"
79: >http://www.oasis-open.org/committees/relax-ng/spec-20011203-errata.html</ulink
80: >.</para>
81:
82: </legalnotice>
83:
84: <abstract>
85: <para>This is the definitive specification of RELAX NG, a simple
86: schema language for XML, based on <xref linkend="relax"/> and <xref
87: linkend="trex"/>. A RELAX NG schema specifies a pattern for the
88: structure and content of an XML document. A RELAX NG schema is itself
89: an XML document.</para>
90: </abstract>
91:
92: <revhistory>
93: <revision>
94: <revnumber>Committee Specification</revnumber>
95: <date>3 December 2001</date>
96: </revision>
97: <revision>
98: <revnumber>Committee Specification</revnumber>
99: <date>11 August 2001</date>
100: </revision>
101: </revhistory>
102: </articleinfo>
103:
104:
105: <section>
106: <title>Introduction</title>
107:
108: <para>This document specifies</para>
109:
110: <itemizedlist>
111:
112: <listitem><para>when an XML document is a correct RELAX NG
113: schema</para></listitem>
114:
115: <listitem><para>when an XML document is valid with respect to a
116: correct RELAX NG schema</para></listitem>
117:
118: </itemizedlist>
119:
120: <para>An XML document that is being validated with respect to a RELAX NG
121: schema is referred to as an instance.</para>
122:
123: <para>The structure of this document is as follows. <xref
124: linkend="data-model"/> describes the data model, which is the
125: abstraction of an XML document used throughout the rest of the
126: document. <xref linkend="full-syntax"/> describes the syntax of a
127: RELAX NG schema; any correct RELAX NG schema must conform to this
128: syntax. <xref linkend="simplification"/> describes a sequence of
129: transformations that are applied to simplify a RELAX NG schema;
130: applying the transformations also involves checking certain
131: restrictions that must be satisfied by a correct RELAX NG
132: schema. <xref linkend="simple-syntax"/> describes the syntax that
133: results from applying the transformations; this simple syntax is a
134: subset of the full syntax. <xref linkend="semantics"/> describes the
135: semantics of a correct RELAX NG schema that uses the simple syntax;
136: the semantics specify when an element is valid with respect to a RELAX
137: NG schema. <xref linkend="restriction"/> describes restrictions in
138: terms of the simple syntax; a correct RELAX NG schema must be such
139: that, after transformation into the simple form, it satisfies these
140: restrictions. Finally, <xref linkend="conformance"/> describes
141: conformance requirements for RELAX NG validators.</para>
142:
143: <para>A tutorial is available separately (see <xref
144: linkend="tutorial"/>).</para>
145:
146: </section>
147:
148: <section id="data-model">
149: <title>Data model</title>
150:
151: <para>RELAX NG deals with XML documents representing both schemas and
152: instances through an abstract data model. XML documents representing
153: schemas and instances must be well-formed in conformance with <xref
154: linkend="xml-rec"/> and must conform to the constraints of <xref
155: linkend="xml-names"/>.</para>
156:
157: <para>An XML document is represented by an element. An element consists
158: of</para>
159:
160: <itemizedlist>
161:
162: <listitem><para>a name</para></listitem>
163:
164: <listitem><para>a context</para></listitem>
165:
166: <listitem><para>a set of attributes</para></listitem>
167:
168: <listitem><para>an ordered sequence of zero or more children; each
169: child is either an element or a non-empty string; the sequence never contains
170: two consecutive strings</para></listitem>
171:
172: </itemizedlist>
173:
174: <para>A name consists of</para>
175:
176: <itemizedlist>
177: <listitem><para>a string representing the namespace URI; the empty
178: string has special significance, representing the absence of any
179: namespace</para></listitem>
180:
181: <listitem><para>a string representing the local name; this string matches the NCName
182: production of <xref linkend="xml-names"/></para></listitem>
183: </itemizedlist>
184:
185: <para>A context consists of</para>
186:
187: <itemizedlist>
188: <listitem><para>a base URI</para></listitem>
189: <listitem><para>a namespace map; this maps prefixes to namespace URIs,
190: and also may specify a default namespace URI (as declared
191: by the <literal>xmlns</literal> attribute)</para></listitem>
192: </itemizedlist>
193:
194: <para>An attribute consists of</para>
195:
196: <itemizedlist>
197: <listitem><para>a name</para></listitem>
198: <listitem><para>a string representing the value</para></listitem>
199: </itemizedlist>
200:
201: <para>A string consists of a sequence of zero or more characters,
202: where a character is as defined in <xref linkend="xml-rec"/>.</para>
203:
204: <para>The element for an XML document is constructed from an instance
205: of the <xref linkend="infoset"/> as follows. We use the notation
206: [<replaceable>x</replaceable>] to refer to the value of the
207: <replaceable>x</replaceable> property of an information item. An
208: element is constructed from a document information item by
209: constructing an element from the [document element]. An element is
210: constructed from an element information item by constructing the name
211: from the [namespace name] and [local name], the context from the [base
212: URI] and [in-scope namespaces], the attributes from the [attributes],
213: and the children from the [children]. The attributes of an element
214: are constructed from the unordered set of attribute information items
215: by constructing an attribute for each attribute information item. The
216: children of an element are constructed from the list of child
217: information items first by removing information items other than
218: element information items and character information items, and then by
219: constructing an element for each element information item in the list
220: and a string for each maximal sequence of character information items.
221: An attribute is constructed from an attribute information item by
222: constructing the name from the [namespace name] and [local name], and
223: the value from the [normalized value]. When constructing the name of
224: an element or attribute from the [namespace name] and [local name], if
225: the [namespace name] property is not present, then the name is
226: constructed from an empty string and the [local name]. A string is
227: constructed from a sequence of character information items by
228: constructing a character from the [character code] of each character
229: information item.</para>
230:
231: <para>It is possible for there to be multiple distinct infosets for a
232: single XML document. This is because XML parsers are not required to
233: process all DTD declarations or expand all external parsed general
234: entities. Amongst these multiple infosets, there is exactly one
235: infoset for which [all declarations processed] is true and which does
236: not contain any unexpanded entity reference information items. This
237: is the infoset that is the basis for defining the RELAX NG data
238: model.</para>
239:
240: <section id="data-model-example">
241: <title>Example</title>
242:
243: <para>Suppose the document
244: <literal>http://www.example.com/doc.xml</literal> is as
245: follows:</para>
246:
247: <programlisting><![CDATA[<?xml version="1.0"?>
248: <foo><pre1:bar1 xmlns:pre1="http://www.example.com/n1"/><pre2:bar2
249: xmlns:pre2="http://www.example.com/n2"/></foo>
250: ]]></programlisting>
251:
252: <para>The element representing this document has</para>
253:
254: <itemizedlist>
255: <listitem><para>a name which has</para>
256: <itemizedlist>
257:
258: <listitem><para>the empty string as the namespace URI, representing
259: the absence of any namespace</para></listitem>
260:
261: <listitem><para><literal>foo</literal> as the local
262: name</para></listitem>
263:
264: </itemizedlist>
265:
266: </listitem>
267:
268: <listitem><para>a context which has</para>
269:
270: <itemizedlist>
271: <listitem><para><literal>http://www.example.com/doc.xml</literal> as the base
272: URI</para></listitem>
273:
274: <listitem><para>a namespace map which</para>
275:
276: <itemizedlist>
277:
278: <listitem><para>maps the prefix <literal>xml</literal> to the
279: namespace URI
280: <literal>http://www.w3.org/XML/1998/namespace</literal>
281: (the <literal>xml</literal> prefix is implicitly declared
282: by every XML document)</para></listitem>
283:
284: <listitem><para>specifies the empty string as the default namespace
285: URI</para></listitem>
286:
287: </itemizedlist>
288:
289: </listitem>
290:
291: </itemizedlist>
292:
293: </listitem>
294:
295: <listitem><para>an empty set of attributes</para></listitem>
296:
297: <listitem><para>a sequence of children consisting
298: of an element which has</para>
299:
300: <itemizedlist>
301: <listitem><para>a name which has</para>
302: <itemizedlist>
303:
304: <listitem><para><literal>http://www.example.com/n1</literal> as the
305: namespace URI</para></listitem>
306:
307: <listitem><para><literal>bar1</literal> as the local
308: name</para></listitem>
309:
310: </itemizedlist>
311:
312: </listitem>
313:
314: <listitem><para>a context which has</para>
315:
316: <itemizedlist>
317: <listitem><para><literal>http://www.example.com/doc.xml</literal> as the base
318: URI</para></listitem>
319:
320: <listitem><para>a namespace map which</para>
321:
322: <itemizedlist>
323:
324: <listitem><para>maps the prefix <literal>pre1</literal> to the
325: namespace URI
326: <literal>http://www.example.com/n1</literal></para></listitem>
327:
328: <listitem><para>maps the prefix <literal>xml</literal> to the
329: namespace URI
330: <literal>http://www.w3.org/XML/1998/namespace</literal></para></listitem>
331:
332: <listitem><para>specifies the empty string as the default namespace
333: URI</para></listitem>
334:
335: </itemizedlist>
336:
337: </listitem>
338:
339: </itemizedlist>
340:
341: </listitem>
342:
343: <listitem><para>an empty set of attributes</para></listitem>
344:
345: <listitem><para>an empty sequence of children</para></listitem>
346:
347: </itemizedlist>
348:
349: <para>followed by an element which has</para>
350:
351: <itemizedlist>
352: <listitem><para>a name which has</para>
353: <itemizedlist>
354:
355: <listitem><para><literal>http://www.example.com/n2</literal> as the
356: namespace URI</para></listitem>
357:
358: <listitem><para><literal>bar2</literal> as the local
359: name</para></listitem>
360:
361: </itemizedlist>
362:
363: </listitem>
364:
365: <listitem><para>a context which has</para>
366:
367: <itemizedlist>
368: <listitem><para><literal>http://www.example.com/doc.xml</literal> as the base
369: URI</para></listitem>
370:
371: <listitem><para>a namespace map which</para>
372:
373: <itemizedlist>
374:
375: <listitem><para>maps the prefix <literal>pre2</literal> to the
376: namespace URI
377: <literal>http://www.example.com/n2</literal></para></listitem>
378:
379: <listitem><para>maps the prefix <literal>xml</literal> to the
380: namespace URI
381: <literal>http://www.w3.org/XML/1998/namespace</literal></para></listitem>
382:
383: <listitem><para>specifies the empty string as the default namespace
384: URI</para></listitem>
385:
386: </itemizedlist>
387:
388: </listitem>
389:
390: </itemizedlist>
391:
392: </listitem>
393:
394: <listitem><para>an empty set of attributes</para></listitem>
395:
396: <listitem><para>an empty sequence of children</para></listitem>
397:
398: </itemizedlist>
399:
400: </listitem>
401: </itemizedlist>
402:
403: </section>
404:
405: </section>
406:
407: <section id="full-syntax">
408: <title>Full syntax</title>
409:
410: <para>The following grammar summarizes the syntax of RELAX NG.
411: Although we use a notation based on the XML representation of an RELAX
412: NG schema as a sequence of characters, the grammar must be understood
413: as operating at the data model level. For example, although the
414: syntax uses <literal><![CDATA[<text/>]]></literal>, an instance or
415: schema can use <literal><![CDATA[<text></text>]]></literal> instead,
416: because they both represent the same element at the data model level.
417: All elements shown in the grammar are qualified with the namespace
418: URI:</para>
419:
420: <programlisting>http://relaxng.org/ns/structure/1.0</programlisting>
421:
422: <para>The symbols QName and NCName are defined in <xref
423: linkend="xml-names"/>. The anyURI symbol has the same meaning as the
424: anyURI datatype of <xref linkend="xmlschema-2"/>: it indicates a
425: string that, after escaping of disallowed values as described in
426: Section 5.4 of <xref linkend="xlink"/>, is a URI reference as defined
427: in <xref linkend="rfc2396"/> (as modified by <xref
428: linkend="rfc2732"/>). The symbol string matches any string.</para>
429:
430: <para>In addition to the attributes shown explicitly, any element can
431: have an <literal>ns</literal> attribute and any element can have a
432: <literal>datatypeLibrary</literal> attribute. The
433: <literal>ns</literal> attribute can have any value. The value of the
434: <literal>datatypeLibrary</literal> attribute must match the anyURI
435: symbol as described in the previous paragraph; in addition, it must
436: not use the relative form of URI reference and must not have a
437: fragment identifier; as an exception to this, the value may be the
438: empty string.</para>
439:
440: <para>Any element can also have foreign attributes in addition to the
441: attributes shown in the grammar. A foreign attribute is an attribute
442: with a name whose namespace URI is neither the empty string nor the
443: RELAX NG namespace URI. Any element that cannot have string children
444: (that is, any element other than <literal>value</literal>, <literal>param</literal>
445: and <literal>name</literal>) may have foreign child elements in addition
446: to the child elements shown in the grammar. A foreign element is an
447: element with a name whose namespace URI is not the RELAX NG namespace
448: URI. There are no constraints on the relative position of foreign
449: child elements with respect to other child elements.</para>
450:
451: <para>Any element can also have as children strings that consist
452: entirely of whitespace characters, where a whitespace character is one
453: of #x20, #x9, #xD or #xA. There are no constraints on the relative
454: position of whitespace string children with respect to child
455: elements.</para>
456:
457: <para>Leading and trailing whitespace is allowed for value of each
458: <literal>name</literal>, <literal>type</literal> and
459: <literal>combine</literal> attribute and for the content of each
460: <literal>name</literal> element.</para>
461:
462: <grammarref src="full.rng"/>
463:
464: <section id="full-syntax-example">
465: <title>Example</title>
466:
467: <para>Here is an example of a schema in the full syntax for the
468: document in <xref linkend="data-model-example"/>.</para>
469:
470: <programlisting><![CDATA[<?xml version="1.0"?>
471: <element name="foo"
472: xmlns="http://relaxng.org/ns/structure/1.0"
473: xmlns:a="http://relaxng.org/ns/annotation/1.0"
474: xmlns:ex1="http://www.example.com/n1"
475: xmlns:ex2="http://www.example.com/n2">
476: <a:documentation>A foo element.</a:document>
477: <element name="ex1:bar1">
478: <empty/>
479: </element>
480: <element name="ex2:bar2">
481: <empty/>
482: </element>
483: </element>]]></programlisting>
484:
485: </section>
486:
487: </section>
488:
489: <section id="simplification">
490: <title>Simplification</title>
491:
492: <para>The full syntax given in the previous section is transformed
493: into a simpler syntax by applying the following transformation rules
494: in order. The effect must be as if each rule was applied to all
495: elements in the schema before the next rule is applied. A
496: transformation rule may also specify constraints that must be
497: satisfied by a correct schema. The transformation rules are applied
498: at the data model level. Before the transformations are applied, the
499: schema is parsed into an instance of the data model.</para>
500:
501: <section>
502: <title>Annotations</title>
503:
504: <para>Foreign attributes and elements are removed.</para>
505:
506: <note><para>It is safe to remove <literal>xml:base</literal>
507: attributes at this stage because <literal>xml:base</literal>
508: attributes are used in determining the [base URI] of an element
509: information item, which is in turn used to construct the base URI of
510: the context of an element. Thus, after a document has been parsed
511: into an instance of the data model, <literal>xml:base</literal>
512: attributes can be discarded.</para></note>
513:
514: </section>
515:
516: <section>
517: <title>Whitespace</title>
518:
519: <para>For each element other than <literal>value</literal> and
520: <literal>param</literal>, each child that is a string containing only
521: whitespace characters is removed.</para>
522:
523: <para>Leading and trailing whitespace characters are removed from the
524: value of each <literal>name</literal>, <literal>type</literal> and
525: <literal>combine</literal> attribute and from the content of each
526: <literal>name</literal> element.</para>
527:
528: </section>
529:
530: <section>
531: <title><literal>datatypeLibrary</literal> attribute</title>
532:
533: <para>The value of each <literal>datatypeLibary</literal> attribute is
534: transformed by escaping disallowed characters as specified in Section
535: 5.4 of <xref linkend="xlink"/>.</para>
536:
537: <para>For any <literal>data</literal> or <literal>value</literal>
538: element that does not have a <literal>datatypeLibrary</literal>
539: attribute, a <literal>datatypeLibrary</literal> attribute is
540: added. The value of the added <literal>datatypeLibrary</literal>
541: attribute is the value of the <literal>datatypeLibrary</literal>
542: attribute of the nearest ancestor element that has a
543: <literal>datatypeLibrary</literal> attribute, or the empty string if
544: there is no such ancestor. Then, any <literal>datatypeLibrary</literal>
545: attribute that is on an element other than <literal>data</literal> or
546: <literal>value</literal> is removed.</para>
547:
548: </section>
549:
550: <section>
551: <title><literal>type</literal> attribute of <literal>value</literal> element</title>
552:
553: <para>For any <literal>value</literal> element that does not have a
554: <literal>type</literal> attribute, a <literal>type</literal> attribute
555: is added with value <literal>token</literal> and the value of the
556: <literal>datatypeLibrary</literal> attribute is changed to the empty
557: string.</para>
558:
559: </section>
560:
561: <section id="href">
562: <title><literal>href</literal> attribute</title>
563:
564: <para>The value of the <literal>href</literal> attribute on an
565: <literal>externalRef</literal> or <literal>include</literal> element
566: is first transformed by escaping disallowed characters as specified in
567: Section 5.4 of <xref linkend="xlink"/>. The URI reference is then
568: resolved into an absolute form as described in section 5.2 of <xref
569: linkend="rfc2396"/> using the base URI from the context of the element
570: that bears the <literal>href</literal> attribute.</para>
571:
572: <para>The value of the <literal>href</literal> attribute will be used
573: to construct an element (as specified in <xref
574: linkend="data-model"/>). This must be done as follows. The URI
575: reference consists of the URI itself and an optional fragment
576: identifier. The resource identified by the URI is retrieved. The
577: result is a MIME entity: a sequence of bytes labeled with a MIME
578: media type. The media type determines how an element is constructed
579: from the MIME entity and optional fragment identifier. When the media
580: type is <literal>application/xml</literal> or
581: <literal>text/xml</literal>, the MIME entity must be parsed as an XML
582: document in accordance with the applicable RFC (at the term of writing
583: <xref linkend="rfc3023"/>) and an element constructed from the result
584: of the parse as specified in <xref linkend="data-model"/>. In
585: particular, the <literal>charset</literal> parameter must be handled
586: as specified by the RFC. This specification does not define the
587: handling of media types other than <literal>application/xml</literal>
588: and <literal>text/xml</literal>. The <literal>href</literal> attribute
589: must not include a fragment identifier unless the registration of the
590: media type of the resource identified by the attribute defines the
591: interpretation of fragment identifiers for that media type.</para>
592:
593: <note><para><xref linkend="rfc3023"/> does not define the
594: interpretation of fragment identifiers for
595: <literal>application/xml</literal> or
596: <literal>text/xml</literal>.</para></note>
597:
598: </section>
599:
600: <section>
601: <title><literal>externalRef</literal> element</title>
602:
603: <para>An <literal>externalRef</literal> element is transformed as
604: follows. An element is constructed using the URI reference that is
605: the value of <literal>href</literal> attribute as specified in <xref
606: linkend="href"/>. This element must match the syntax for pattern. The
607: element is transformed by recursively applying the rules from this
608: subsection and from previous subsections of this section. This must
609: not result in a loop. In other words, the transformation of the
610: referenced element must not require the dereferencing of an
611: <literal>externalRef</literal> attribute with an
612: <literal>href</literal> attribute with the same value.</para>
613:
614: <para>Any <literal>ns</literal> attribute on the
615: <literal>externalRef</literal> element is transferred to the
616: referenced element if the referenced element does not already have an
617: <literal>ns</literal> attribute. The <literal>externalRef</literal>
618: element is then replaced by the referenced element.</para>
619:
620: </section>
621:
622: <section>
623: <title><literal>include</literal> element</title>
624:
625: <para>An <literal>include</literal> element is transformed as follows.
626: An element is constructed using the URI reference that is the value of
627: <literal>href</literal> attribute as specified in <xref
628: linkend="href"/>. This element must be a <literal>grammar</literal>
629: element, matching the syntax for grammar.</para>
630:
631: <para>This <literal>grammar</literal> element is transformed by
632: recursively applying the rules from this subsection and from previous
633: subsections of this section. This must not result in a loop. In other
634: words, the transformation of the <literal>grammar</literal> element
635: must not require the dereferencing of an <literal>include</literal>
636: attribute with an <literal>href</literal> attribute with the same
637: value.</para>
638:
639: <para>Define the <firstterm>components</firstterm> of an element to
640: be the children of the element together with the components of any
641: <literal>div</literal> child elements. If the
642: <literal>include</literal> element has a <literal>start</literal>
643: component, then the <literal>grammar</literal> element must have a
644: <literal>start</literal> component. If the <literal>include</literal>
645: element has a <literal>start</literal> component, then all
646: <literal>start</literal> components are removed from the
647: <literal>grammar</literal> element. If the <literal>include</literal>
648: element has a <literal>define</literal> component, then the
649: <literal>grammar</literal> element must have a
650: <literal>define</literal> component with the same name. For every
651: <literal>define</literal> component of the <literal>include</literal>
652: element, all <literal>define</literal> components with the same name
653: are removed from the <literal>grammar</literal> element.</para>
654:
655: <para>The <literal>include</literal> element is transformed into a
656: <literal>div</literal> element. The attributes of the
657: <literal>div</literal> element are the attributes of the
658: <literal>include</literal> element other than the
659: <literal>href</literal> attribute. The children of the
660: <literal>div</literal> element are the <literal>grammar</literal>
661: element (after the removal of the <literal>start</literal> and
662: <literal>define</literal> components described by the preceding
663: paragraph) followed by the children of the <literal>include</literal>
664: element. The <literal>grammar</literal> element is then renamed to
665: <literal>div</literal>.</para>
666:
667: </section>
668:
669: <section>
670: <title><literal>name</literal> attribute of <literal>element</literal>
671: and <literal>attribute</literal> elements</title>
672:
673: <para>The <literal>name</literal> attribute on an
674: <literal>element</literal> or <literal>attribute</literal> element is
675: transformed into a <literal>name</literal> child element.</para>
676:
677: <para>If an <literal>attribute</literal> element has a
678: <literal>name</literal> attribute but no <literal>ns</literal>
679: attribute, then an <literal>ns=""</literal> attribute is added to the
680: <literal>name</literal> child element.</para>
681:
682: </section>
683:
684: <section>
685: <title><literal>ns</literal> attribute</title>
686:
687: <para>For any <literal>name</literal>, <literal>nsName</literal> or
688: <literal>value</literal> element that does not have an
689: <literal>ns</literal> attribute, an <literal>ns</literal> attribute is
690: added. The value of the added <literal>ns</literal> attribute is the
691: value of the <literal>ns</literal> attribute of the nearest ancestor
692: element that has an <literal>ns</literal> attribute, or the empty
693: string if there is no such ancestor. Then, any <literal>ns</literal>
694: attribute that is on an element other than <literal>name</literal>,
695: <literal>nsName</literal> or <literal>value</literal> is
696: removed.</para>
697:
698: <note><para>The value of the <literal>ns</literal> attribute is
699: <emphasis role="strong">not</emphasis> transformed either by escaping
700: disallowed characters, or in any other way, because the value of the
701: <literal>ns</literal> attribute is compared against namespace URIs in
702: the instance, which are not subject to any
703: transformation.</para></note>
704:
705: <note><para>Since <literal>include</literal> and
706: <literal>externalRef</literal> elements are resolved after
707: <literal>datatypeLibrary</literal> attributes are added but before
708: <literal>ns</literal> attributes are added, <literal>ns</literal>
709: attributes are inherited into external schemas but
710: <literal>datatypeLibrary</literal> attributes are not.</para></note>
711:
712: </section>
713:
714: <section>
715: <title>QNames</title>
716:
717: <para>For any <literal>name</literal> element containing a prefix, the
718: prefix is removed and an <literal>ns</literal> attribute is added
719: replacing any existing <literal>ns</literal> attribute. The value of
720: the added <literal>ns</literal> attribute is the value to which the
721: namespace map of the context of the <literal>name</literal> element
722: maps the prefix. The context must have a mapping for the
723: prefix.</para>
724:
725: </section>
726:
727: <section>
728: <title><literal>div</literal> element</title>
729:
730: <para>Each <literal>div</literal> element is replaced by its
731: children.</para>
732:
733: </section>
734:
735: <section id="number-child-elements">
736: <title>Number of child elements</title>
737:
738: <para>A <literal>define</literal>, <literal>oneOrMore</literal>,
739: <literal>zeroOrMore</literal>, <literal>optional</literal>, <literal>list</literal> or
740: <literal>mixed</literal> element is transformed so that it has exactly
741: one child element. If it has more than one child element, then its
742: child elements are wrapped in a <literal>group</literal>
743: element. Similarly, an <literal>element</literal> element is transformed so
744: that it has exactly two child elements, the first being a name class
745: and the second being a pattern. If it has more than two child elements,
746: then the child elements other than the first are wrapped in a
747: <literal>group</literal> element.</para>
748:
749: <para>A <literal>except</literal> element is transformed
750: so that it has exactly one child element. If it has more
751: than one child element, then its child elements are wrapped
752: in a <literal>choice</literal> element.</para>
753:
754: <para>If an <literal>attribute</literal> element has only one child
755: element (a name class), then a <literal>text</literal> element is
756: added.</para>
757:
758: <para>A <literal>choice</literal>, <literal>group</literal> or
759: <literal>interleave</literal> element is transformed so that it has
760: exactly two child elements. If it has one child element, then it is
761: replaced by its child element. If it has more than two child
762: elements, then the first two child elements are combined into a new
763: element with the same name as the parent element and with the first
764: two child elements as its children. For example,</para>
765:
766: <programlisting><choice> <replaceable>p1</replaceable> <replaceable>p2</replaceable> <replaceable>p3</replaceable> </choice></programlisting>
767:
768: <para>is transformed to</para>
769:
770: <programlisting><choice> <choice> <replaceable>p1</replaceable> <replaceable>p2</replaceable> </choice> <replaceable>p3</replaceable> </choice></programlisting>
771:
772: <para>This reduces the number of child elements by one. The
773: transformation is applied repeatedly until there are exactly two child
774: elements.</para>
775:
776: </section>
777:
778: <section>
779: <title><literal>mixed</literal> element</title>
780:
781: <para>A <literal>mixed</literal> element is transformed into an
782: interleaving with a <literal>text</literal> element:</para>
783:
784: <programlisting><mixed> <replaceable>p</replaceable> </mixed></programlisting>
785:
786: <para>is transformed into</para>
787:
788: <programlisting><interleave> <replaceable>p</replaceable> <text/> </interleave></programlisting>
789:
790: </section>
791:
792: <section>
793: <title><literal>optional</literal> element</title>
794:
795: <para>An <literal>optional</literal> element is transformed into
796: a choice with <literal>empty</literal>:</para>
797:
798: <programlisting><optional> <replaceable>p</replaceable> </optional></programlisting>
799:
800: <para>is transformed into</para>
801:
802: <programlisting><choice> <replaceable>p</replaceable> <empty/> </choice></programlisting>
803:
804: </section>
805:
806: <section>
807: <title><literal>zeroOrMore</literal> element</title>
808:
809: <para>A <literal>zeroOrMore</literal> element is transformed into a choice
810: between <literal>oneOrMore</literal> and
811: <literal>empty</literal>:</para>
812:
813: <programlisting><zeroOrMore> <replaceable>p</replaceable> </zeroOrMore></programlisting>
814:
815: <para>is transformed into</para>
816:
817: <programlisting><choice> <oneOrMore> <replaceable>p</replaceable> </oneOrMore> <empty/> </choice></programlisting>
818:
819: </section>
820:
821: <section id="constraints">
822: <title>Constraints</title>
823:
824: <para>In this rule, no transformation is performed, but various
825: constraints are checked.</para>
826:
827: <note><para>The constraints in this section, unlike the constraints
828: specified in <xref linkend="restriction"/>, can be checked without
829: resolving any <literal>ref</literal> elements, and are accordingly
830: applied even to patterns that will disappear during later stages of
831: simplification because they are not reachable (see <xref
832: linkend="define-ref"/>) or because of <literal>notAllowed</literal>
833: (see <xref linkend="notAllowed"/>).</para></note>
834:
835: <para>An <literal>except</literal> element that is a child of an
836: <literal>anyName</literal> element must not have any
837: <literal>anyName</literal> descendant elements. An
838: <literal>except</literal> element that is a child of an
839: <literal>nsName</literal> element must not have any
840: <literal>nsName</literal> or <literal>anyName</literal> descendant
841: elements.</para>
842:
843: <para>A <literal>name</literal> element that occurs as the first child
844: of an <literal>attribute</literal> element or as the descendant of the
845: first child of an <literal>attribute</literal> element and that has an
846: <literal>ns</literal> attribute with value equal to the empty string
847: must not have content equal to <literal>xmlns</literal>.</para>
848:
849: <para>A <literal>name</literal> or <literal>nsName</literal> element
850: that occurs as the first child of an <literal>attribute</literal>
851: element or as the descendant of the first child of an
852: <literal>attribute</literal> element must not have an
853: <literal>ns</literal> attribute with value
854: <literal>http://www.w3.org/2000/xmlns</literal>.</para>
855:
856: <note><para>The <xref linkend="infoset"/> defines the namespace URI of
857: namespace declaration attributes to be
858: <literal>http://www.w3.org/2000/xmlns</literal>.</para></note>
859:
860: <para>A <literal>data</literal> or <literal>value</literal> element
861: must be correct in its use of datatypes. Specifically, the
862: <literal>type</literal> attribute must identify a datatype within the
863: datatype library identified by the value of the
864: <literal>datatypeLibrary</literal> attribute. For a
865: <literal>data</literal> element, the parameter list must be one that
866: is allowed by the datatype (see <xref
867: linkend="data-pattern"/>).</para>
868:
869: </section>
870:
871: <section>
872: <title><literal>combine</literal> attribute</title>
873:
874: <para>For each <literal>grammar</literal> element, all
875: <literal>define</literal> elements with the same name are combined
876: together. For any name, there must not be more than one
877: <literal>define</literal> element with that name that does not have a
878: <literal>combine</literal> attribute. For any name, if there is a
879: <literal>define</literal> element with that name that has a
880: <literal>combine</literal> attribute with the value
881: <literal>choice</literal>, then there must not also be a
882: <literal>define</literal> element with that name that has a
883: <literal>combine</literal> attribute with the value
884: <literal>interleave</literal>. Thus, for any name, if there is more
885: than one <literal>define</literal> element with that name, then there
886: is a unique value for the <literal>combine</literal> attribute for
887: that name. After determining this unique value, the
888: <literal>combine</literal> attributes are removed. A pair of
889: definitions</para>
890:
891: <programlisting><define name="<replaceable>n</replaceable>">
892: <replaceable>p1</replaceable>
893: </define>
894: <define name="<replaceable>n</replaceable>">
895: <replaceable>p2</replaceable>
896: </define></programlisting>
897:
898: <para>is combined into</para>
899:
900: <programlisting><define name="<replaceable>n</replaceable>">
901: <<replaceable>c</replaceable>>
902: <replaceable>p1</replaceable>
903: <replaceable>p2</replaceable>
904: </<replaceable>c</replaceable>>
905: </define></programlisting>
906:
907: <para>where <replaceable>c</replaceable> is the value of the
908: <literal>combine</literal> attribute. Pairs of definitions are
909: combined until there is exactly one <literal>define</literal> element
910: for each name.</para>
911:
912: <para>Similarly, for each <literal>grammar</literal> element all
913: <literal>start</literal> elements are combined together. There must
914: not be more than one <literal>start</literal> element that does not
915: have a <literal>combine</literal> attribute. If there is a
916: <literal>start</literal> element that has a <literal>combine</literal>
917: attribute with the value <literal>choice</literal>, there must not
918: also be a <literal>start</literal> element that has a
919: <literal>combine</literal> attribute with the value
920: <literal>interleave</literal>.</para>
921:
922: </section>
923:
924: <section>
925: <title><literal>grammar</literal> element</title>
926:
927: <para>In this rule, the schema is transformed so that its top-level
928: element is <literal>grammar</literal> and so that it has no other
929: <literal>grammar</literal> elements.</para>
930:
931: <para>Define the <firstterm>in-scope grammar</firstterm> for an
932: element to be the nearest ancestor <literal>grammar</literal> element. A
933: <literal>ref</literal> element <firstterm>refers to</firstterm> a
934: <literal>define</literal> element if the value of their
935: <literal>name</literal> attributes is the same and their in-scope
936: grammars are the same. A <literal>parentRef</literal> element
937: <firstterm>refers to</firstterm> a <literal>define</literal> element
938: if the value of their <literal>name</literal> attributes is the same
939: and the in-scope grammar of the in-scope grammar of the
940: <literal>parentRef</literal> element is the same as the in-scope
941: grammar of the <literal>define</literal> element. Every
942: <literal>ref</literal> or <literal>parentRef</literal> element must
943: refer to a <literal>define</literal> element. A
944: <literal>grammar</literal> must have a <literal>start</literal> child
945: element.</para>
946:
947: <para>First, transform the top-level pattern
948: <replaceable>p</replaceable> into
949: <literal><grammar><start><replaceable>p</replaceable></start></grammar></literal>.
950: Next, rename <literal>define</literal> elements so that no two
951: <literal>define</literal> elements anywhere in the schema have the
952: same name. To rename a <literal>define</literal> element, change the
953: value of its <literal>name</literal> attribute and change the value of
954: the <literal>name</literal> attribute of all <literal>ref</literal>
955: and <literal>parentRef</literal> elements that refer to that
956: <literal>define</literal> element. Next, move all
957: <literal>define</literal> elements to be children of the top-level
958: <literal>grammar</literal> element, replace each nested
959: <literal>grammar</literal> element by the child of its
960: <literal>start</literal> element and rename each
961: <literal>parentRef</literal> element to <literal>ref</literal>.</para>
962:
963: </section>
964:
965:
966: <section id="define-ref">
967: <title><literal>define</literal> and <literal>ref</literal> elements</title>
968:
969: <para>In this rule, the grammar is transformed so that every
970: <literal>element</literal> element is the child of a
971: <literal>define</literal> element, and the child of every
972: <literal>define</literal> element is an <literal>element</literal>
973: element.</para>
974:
975: <para>First, remove any <literal>define</literal> element that is not
976: <firstterm>reachable</firstterm>. A <literal>define</literal> element
977: is reachable if there is reachable <literal>ref</literal> element
978: referring to it. A <literal>ref</literal> element is reachable if it
979: is the descendant of the <literal>start</literal> element or of a
980: reachable <literal>define</literal> element. Now, for
981: each <literal>element</literal> element that is not the child of a
982: <literal>define</literal> element, add a <literal>define</literal>
983: element to the <literal>grammar</literal> element, and replace the
984: <literal>element</literal> element by a <literal>ref</literal> element
985: referring to the added <literal>define</literal> element. The value of
986: the <literal>name</literal> attribute of the added
987: <literal>define</literal> element must be different from value of the
988: <literal>name</literal> attribute of all other
989: <literal>define</literal> elements. The child of the added
990: <literal>define</literal> element is the <literal>element</literal>
991: element.</para>
992:
993: <para>Define a <literal>ref</literal> element to be
994: <firstterm>expandable</firstterm> if it refers to a
995: <literal>define</literal> element whose child is not an
996: <literal>element</literal> element. For each <literal>ref</literal>
997: element that is expandable and is a descendant of a
998: <literal>start</literal> element or an <literal>element</literal>
999: element, expand it by replacing the <literal>ref</literal> element by
1000: the child of the <literal>define</literal> element to which it refers and
1001: then recursively expanding any expandable <literal>ref</literal>
1002: elements in this replacement. This must not result in a loop.
1003: In other words expanding the replacement of a
1004: <literal>ref</literal> element having a <literal>name</literal> with
1005: value <replaceable>n</replaceable> must not require the expansion of
1006: <literal>ref</literal> element also having a <literal>name</literal>
1007: with value <replaceable>n</replaceable>. Finally, remove any
1008: <literal>define</literal> element whose child is not an
1009: <literal>element</literal> element.</para>
1010:
1011: </section>
1012:
1013: <section id="notAllowed">
1014: <title><literal>notAllowed</literal> element</title>
1015:
1016: <para>In this rule, the grammar is transformed so that a
1017: <literal>notAllowed</literal> element occurs only as the child of
1018: a <literal>start</literal> or <literal>element</literal> element. An
1019: <literal>attribute</literal>, <literal>list</literal>,
1020: <literal>group</literal>, <literal>interleave</literal>,
1021: or <literal>oneOrMore</literal> element that has a
1022: <literal>notAllowed</literal> child element is transformed into a
1023: <literal>notAllowed</literal> element. A <literal>choice</literal>
1024: element that has two <literal>notAllowed</literal> child elements is
1025: transformed into a <literal>notAllowed</literal> element. A
1026: <literal>choice</literal> element that has one
1027: <literal>notAllowed</literal> child element is transformed into its
1028: other child element. An <literal>except</literal> element that has a
1029: <literal>notAllowed</literal> child element is removed.
1030: The preceding transformations are applied
1031: repeatedly until none of them is applicable any more.
1032: Any <literal>define</literal> element that is no longer reachable
1033: is removed.</para>
1034:
1035: </section>
1036:
1037: <section>
1038: <title><literal>empty</literal> element</title>
1039:
1040: <para>In this rule, the grammar is transformed so that an
1041: <literal>empty</literal> element does not occur as a child of a
1042: <literal>group</literal>, <literal>interleave</literal>, or
1043: <literal>oneOrMore</literal> element or as the second child of
1044: a <literal>choice</literal> element. A <literal>group</literal>,
1045: <literal>interleave</literal> or <literal>choice</literal> element
1046: that has two <literal>empty</literal> child elements is transformed
1047: into an <literal>empty</literal> element. A <literal>group</literal>
1048: or <literal>interleave</literal> element that has one
1049: <literal>empty</literal> child element is transformed into its other
1050: child element. A <literal>choice</literal> element whose
1051: second child element is an <literal>empty</literal> element is
1052: transformed by interchanging its two child elements. A
1053: <literal>oneOrMore</literal> element that has an
1054: <literal>empty</literal> child element is transformed into an
1055: <literal>empty</literal> element. The preceding transformations are applied
1056: repeatedly until none of them is applicable any more.</para>
1057:
1058: </section>
1059:
1060: </section>
1061:
1062: <section id="simple-syntax">
1063: <title>Simple syntax</title>
1064:
1065: <para>After applying all the rules in <xref
1066: linkend="simplification"/>, the schema will match the following
1067: grammar:</para>
1068:
1069: <grammarref src="simple.rng"/>
1070:
1071: <para>With this grammar, no elements or attributes are allowed other
1072: than those explicitly shown.</para>
1073:
1074: <section id="simple-syntax-example">
1075: <title>Example</title>
1076:
1077: <para>The following is an example of how the schema in <xref
1078: linkend="full-syntax-example"/> can be transformed into the simple
1079: syntax:</para>
1080:
1081: <programlisting><![CDATA[<?xml version="1.0"?>
1082: <grammar xmlns="http://relaxng.org/ns/structure/1.0">
1083: <start>
1084: <ref name="foo.element"/>
1085: </start>
1086:
1087: <define name="foo.element">
1088: <element>
1089: <name ns="">foo</name>
1090: <group>
1091: <ref name="bar1.element"/>
1092: <ref name="bar2.element"/>
1093: </group>
1094: </element>
1095: </define>
1096:
1097: <define name="bar1.element">
1098: <element>
1099: <name ns="http://www.example.com/n1">bar1</name>
1100: <empty/>
1101: </element>
1102: </define>
1103:
1104: <define name="bar2.element">
1105: <element>
1106: <name ns="http://www.example.com/n2">bar2</name>
1107: <empty/>
1108: </element>
1109: </define>
1110: </grammar>]]></programlisting>
1111:
1112: <note><para>Strictly speaking, the result of simplification is an
1113: instance of the data model rather than an XML document. For
1114: convenience, we use an XML document to represent an instance of the
1115: data model.</para></note>
1116:
1117: </section>
1118:
1119: </section>
1120:
1121: <section id="semantics">
1122: <title>Semantics</title>
1123:
1124: <para>In this section, we define the semantics of a correct RELAX NG
1125: schema that has been transformed into the simple syntax. The
1126: semantics of a RELAX NG schema consist of a specification of what XML
1127: documents are valid with respect to that schema. The semantics are
1128: described formally. The formalism uses axioms and inference rules.
1129: Axioms are propositions that are provable unconditionally. An
1130: inference rule consists of one or more antecedents and exactly one
1131: consequent. An antecedent is either positive or negative. If all the
1132: positive antecedents of an inference rule are provable and none of the
1133: negative antecedents are provable, then the consequent of the
1134: inference rule is provable. An XML document is valid with respect to a
1135: RELAX NG schema if and only if the proposition that it is valid is
1136: provable in the formalism specified in this section.</para>
1137:
1138: <note><para>This kind of formalism is similar to a proof system.
1139: However, a traditional proof system only has positive
1140: antecedents.</para></note>
1141:
1142: <para>The notation for inference rules separates the antecedents from
1143: the consequent by a horizontal line: the antecedents are above the
1144: line; the consequent is below the line. If an antecedent is of the
1145: form not(<replaceable>p</replaceable>), then it is a negative
1146: antecedent; otherwise, it is a positive antecedent. Both axioms and
1147: inferences
1148: rules may use variables. A variable has a name and optionally a
1149: subscript. The name of a variable is italicized. Each variable has a
1150: range that is determined by its name. Axioms and inference rules are
1151: implicitly universally quantified over the variables they contain. We
1152: explain this further below.</para>
1153:
1154: <para>The possibility that an inference rule or axiom may contain more
1155: than one occurrence of a particular variable requires that an identity
1156: relation be defined on each kind of object over which a variable can
1157: range. The identity relation for all kinds of object is value-based.
1158: Two objects of a particular kind are identical if the constituents of
1159: the objects are identical. For example, two attributes are considered
1160: the same if they have the same name and the same value. Two characters
1161: are identical if their Unicode character codes are the same.</para>
1162:
1163: <section id="name-classes">
1164: <title>Name classes</title>
1165:
1166: <para>The main semantic concept for name classes is that of a name
1167: belonging to a name class. A name class is an element that matches the
1168: production nameClass. A name is as defined in <xref
1169: linkend="data-model"/>: it consists of a namespace URI and a local
1170: name.</para>
1171:
1172: <para>We use the following notation:</para>
1173:
1174: <variablelist>
1175:
1176: <varlistentry><term><p:var range="name"/></term><listitem><para>is a variable
1177: that ranges over names</para></listitem></varlistentry>
1178:
1179: <varlistentry><term><p:var range="nameClass"/></term><listitem><para>ranges over name classes</para></listitem></varlistentry>
1180:
1181: <varlistentry><term><p:judgement name="belongs">
1182: <p:var range="name"/>
1183: <p:var range="nameClass"/>
1184: </p:judgement></term><listitem><para>
1185:
1186: asserts that name <p:var range="name"/> is a member of name class <p:var range="nameClass"/>
1187:
1188: </para></listitem></varlistentry>
1189:
1190: </variablelist>
1191:
1192: <para>We are now ready for our first axiom, which is called "anyName
1193: 1":</para>
1194:
1195: <p:proofSystem>
1196: <p:rule name="anyName 1">
1197: <p:judgement name="belongs">
1198: <p:var range="name"/>
1199: <p:element name="anyName"/>
1200: </p:judgement>
1201: </p:rule>
1202: </p:proofSystem>
1203:
1204: <para>This says for any name <p:var range="name"/>, <p:var
1205: range="name"/> belongs to the name class <p:element name="anyName"/>,
1206: in other words <p:element name="anyName"/> matches any name. Note the
1207: effect of the implicit universal quantification over the variables in
1208: the axiom: this is what makes the axiom apply for any name <p:var
1209: range="name"/>.</para>
1210:
1211: <para>Our first inference rule is almost as simple:</para>
1212:
1213: <p:proofSystem>
1214: <p:rule name="anyName 2">
1215: <p:not>
1216: <p:judgement name="belongs">
1217: <p:var range="name"/>
1218: <p:var range="nameClass"/>
1219: </p:judgement>
1220: </p:not>
1221: <p:judgement name="belongs">
1222: <p:var range="name"/>
1223: <p:element name="anyName">
1224: <p:element name="except">
1225: <p:var range="nameClass"/>
1226: </p:element>
1227: </p:element>
1228: </p:judgement>
1229: </p:rule>
1230:
1231: </p:proofSystem>
1232:
1233: <para>This says that for any name <p:var range="name"/>
1234: and for any name class <p:var range="nameClass"/>,
1235: if <p:var range="name"/> does not belong to <p:var range="nameClass"/>,
1236: then <p:var range="name"/> belongs to
1237: <p:element name="anyName">
1238: <p:element name="except">
1239: <p:var range="nameClass"/>
1240: </p:element>
1241: </p:element>. In other words, <p:element name="anyName">
1242: <p:element name="except">
1243: <p:var range="nameClass"/>
1244: </p:element>
1245: </p:element> matches any name that does not match <p:var range="nameClass"/>.</para>
1246:
1247: <para>We now need the following additional notation:</para>
1248:
1249: <variablelist>
1250:
1251: <varlistentry><term><p:var range="ncname"/></term>
1252:
1253: <listitem><para>ranges over local names; a local name is a string that
1254: matches the NCName production of <xref linkend="xml-names"/>, that is,
1255: a name with no colons</para></listitem>
1256: </varlistentry>
1257:
1258: <varlistentry><term><p:var range="uri"/></term><listitem><para>ranges over URIs</para></listitem></varlistentry>
1259:
1260: <varlistentry>
1261: <term>
1262: <p:function name="name">
1263: <p:var range="uri"/>
1264: <p:var range="ncname"/>
1265: </p:function>
1266: </term>
1267: <listitem><para>constructs a name with URI <p:var range="uri"/> and local
1268: name <p:var range="ncname"/></para></listitem>
1269: </varlistentry>
1270:
1271: </variablelist>
1272:
1273: <para>The remaining axioms and inference rules for name classes are as
1274: follows:</para>
1275:
1276: <p:proofSystem>
1277:
1278: <p:rule name="nsName 1">
1279: <p:judgement name="belongs">
1280: <p:function name="name">
1281: <p:var range="uri"/>
1282: <p:var range="ncname"/>
1283: </p:function>
1284: <p:element name="nsName">
1285: <p:attribute name="ns">
1286: <p:var range="uri"/>
1287: </p:attribute>
1288: </p:element>
1289: </p:judgement>
1290: </p:rule>
1291:
1292: <p:rule name="nsName 2">
1293: <p:not>
1294: <p:judgement name="belongs">
1295: <p:function name="name">
1296: <p:var range="uri"/>
1297: <p:var range="ncname"/>
1298: </p:function>
1299: <p:var range="nameClass"/>
1300: </p:judgement>
1301: </p:not>
1302: <p:judgement name="belongs">
1303: <p:function name="name">
1304: <p:var range="uri"/>
1305: <p:var range="ncname"/>
1306: </p:function>
1307: <p:element name="nsName">
1308: <p:attribute name="ns">
1309: <p:var range="uri"/>
1310: </p:attribute>
1311: <p:element name="except">
1312: <p:var range="nameClass"/>
1313: </p:element>
1314: </p:element>
1315: </p:judgement>
1316: </p:rule>
1317:
1318: <p:rule name="name">
1319: <p:judgement name="belongs">
1320: <p:function name="name">
1321: <p:var range="uri"/>
1322: <p:var range="ncname"/>
1323: </p:function>
1324: <p:element name="name">
1325: <p:attribute name="ns">
1326: <p:var range="uri"/>
1327: </p:attribute>
1328: <p:var range="ncname"/>
1329: </p:element>
1330: </p:judgement>
1331: </p:rule>
1332:
1333: <p:rule name="name choice 1">
1334: <p:judgement name="belongs">
1335: <p:var range="name"/>
1336: <p:var range="nameClass" sub="1"/>
1337: </p:judgement>
1338: <p:judgement name="belongs">
1339: <p:var range="name"/>
1340: <p:element name="choice">
1341: <p:var range="nameClass" sub="1"/>
1342: <p:var range="nameClass" sub="2"/>
1343: </p:element>
1344: </p:judgement>
1345: </p:rule>
1346:
1347: <p:rule name="name choice 2">
1348: <p:judgement name="belongs">
1349: <p:var range="name"/>
1350: <p:var range="nameClass" sub="2"/>
1351: </p:judgement>
1352: <p:judgement name="belongs">
1353: <p:var range="name"/>
1354: <p:element name="choice">
1355: <p:var range="nameClass" sub="1"/>
1356: <p:var range="nameClass" sub="2"/>
1357: </p:element>
1358: </p:judgement>
1359: </p:rule>
1360:
1361: </p:proofSystem>
1362:
1363: </section>
1364:
1365:
1366: <section>
1367: <title>Patterns</title>
1368:
1369: <para>The axioms and inference rules for patterns use the following
1370: notation:</para>
1371:
1372: <variablelist>
1373:
1374: <varlistentry><term><p:var range="context"/></term><listitem><para>ranges
1375: over contexts (as defined in <xref
1376: linkend="data-model"/>)</para></listitem></varlistentry>
1377:
1378: <varlistentry><term><p:var range="att"/></term><listitem><para>ranges over
1379: sets of attributes; a set with a single member
1380: is considered the same as that member</para></listitem></varlistentry>
1381:
1382: <varlistentry><term><p:var
1383: range="mixed"/></term><listitem><para>ranges over sequences of
1384: elements and strings; a sequence with a single member is considered
1385: the same as that member; the sequences ranged over by <p:var
1386: range="mixed"/> may contain consecutive strings and may contain strings
1387: that are empty; thus, there are sequences ranged over by <p:var
1388: range="mixed"/> that cannot occur as the children of an
1389: element</para></listitem></varlistentry>
1390:
1391: <varlistentry><term><p:var range="pattern"/></term><listitem><para>ranges
1392: over patterns (elements matching the pattern
1393: production)</para></listitem></varlistentry>
1394:
1395: <varlistentry><term><p:judgement name="match">
1396: <p:var range="context"/>
1397: <p:var range="att"/>
1398: <p:var range="mixed"/>
1399: <p:var range="pattern"/>
1400: </p:judgement></term><listitem><para>
1401:
1402: asserts that with respect to context <p:var range="context"/>, the
1403: attributes <p:var range="att"/> and the sequence of elements and
1404: strings <p:var range="mixed"/> matches the pattern <p:var
1405: range="pattern"/></para></listitem></varlistentry>
1406:
1407: </variablelist>
1408:
1409: <section id="choice-pattern">
1410: <title><literal>choice</literal> pattern</title>
1411:
1412: <para>The semantics of the <literal>choice</literal> pattern are as follows:</para>
1413:
1414: <p:proofSystem>
1415: <p:rule name="choice 1">
1416:
1417: <p:judgement name="match">
1418: <p:var range="context"/>
1419: <p:var range="att"/>
1420: <p:var range="mixed"/>
1421: <p:var range="pattern" sub="1"/>
1422: </p:judgement>
1423:
1424: <p:judgement name="match">
1425: <p:var range="context"/>
1426: <p:var range="att"/>
1427: <p:var range="mixed"/>
1428: <p:element name="choice">
1429: <p:var range="pattern" sub="1"/>
1430: <p:var range="pattern" sub="2"/>
1431: </p:element>
1432: </p:judgement>
1433:
1434: </p:rule>
1435:
1436: <p:rule name="choice 2">
1437:
1438: <p:judgement name="match">
1439: <p:var range="context"/>
1440: <p:var range="att"/>
1441: <p:var range="mixed"/>
1442: <p:var range="pattern" sub="2"/>
1443: </p:judgement>
1444:
1445: <p:judgement name="match">
1446: <p:var range="context"/>
1447: <p:var range="att"/>
1448: <p:var range="mixed"/>
1449: <p:element name="choice">
1450: <p:var range="pattern" sub="1"/>
1451: <p:var range="pattern" sub="2"/>
1452: </p:element>
1453: </p:judgement>
1454:
1455: </p:rule>
1456:
1457:
1458: </p:proofSystem>
1459:
1460: </section>
1461:
1462: <section>
1463: <title><literal>group</literal> pattern</title>
1464:
1465: <para>We use the following additional notation:</para>
1466:
1467: <variablelist>
1468:
1469: <varlistentry><term><p:function name="append">
1470: <p:var range="mixed" sub="1"/>
1471: <p:var range="mixed" sub="2"/>
1472: </p:function></term><listitem>
1473: <para>represents the concatenation of the sequences <p:var range="mixed" sub="1"/> and <p:var range="mixed" sub="2"/>
1474:
1475: </para></listitem></varlistentry>
1476:
1477: <varlistentry><term><p:function name="union">
1478: <p:var range="att" sub="1"/>
1479: <p:var range="att" sub="2"/>
1480: </p:function></term><listitem>
1481: <para>represents the union of <p:var range="att" sub="1"/>
1482: and <p:var range="att" sub="2"/></para>
1483: </listitem>
1484: </varlistentry>
1485:
1486: </variablelist>
1487:
1488: <para>The semantics of the <literal>group</literal> pattern are as follows:</para>
1489:
1490: <p:proofSystem>
1491: <p:rule name="group">
1492:
1493: <p:judgement name="match">
1494: <p:var range="context"/>
1495: <p:var range="att" sub="1"/>
1496: <p:var range="mixed" sub="1"/>
1497: <p:var range="pattern" sub="1"/>
1498: </p:judgement>
1499:
1500: <p:judgement name="match">
1501: <p:var range="context"/>
1502: <p:var range="att" sub="2"/>
1503: <p:var range="mixed" sub="2"/>
1504: <p:var range="pattern" sub="2"/>
1505: </p:judgement>
1506:
1507: <p:judgement name="match">
1508: <p:var range="context"/>
1509: <p:function name="union">
1510: <p:var range="att" sub="1"/>
1511: <p:var range="att" sub="2"/>
1512: </p:function>
1513: <p:function name="append">
1514: <p:var range="mixed" sub="1"/>
1515: <p:var range="mixed" sub="2"/>
1516: </p:function>
1517: <p:element name="group">
1518: <p:var range="pattern" sub="1"/>
1519: <p:var range="pattern" sub="2"/>
1520: </p:element>
1521: </p:judgement>
1522:
1523: </p:rule>
1524:
1525: </p:proofSystem>
1526:
1527: <note><para>The restriction in <xref linkend="attribute-restrictions"/>
1528: ensures that the set of attributes constructed in the consequent will
1529: not have multiple attributes with the same name.</para></note>
1530:
1531: </section>
1532:
1533:
1534: <section id="empty-pattern">
1535: <title><literal>empty</literal> pattern</title>
1536:
1537: <para>We use the following additional notation:</para>
1538:
1539: <variablelist>
1540: <varlistentry><term><p:function name="emptySequence"/></term><listitem><para>represents an empty sequence</para></listitem></varlistentry>
1541:
1542: <varlistentry><term><p:function name="emptySet"/></term><listitem><para>represents an empty set</para></listitem></varlistentry>
1543:
1544: </variablelist>
1545:
1546: <para>The semantics of the <literal>empty</literal> pattern are as follows:</para>
1547:
1548: <p:proofSystem>
1549: <p:rule name="empty">
1550: <p:judgement name="match">
1551: <p:var range="context"/>
1552: <p:function name="emptySet"/>
1553: <p:function name="emptySequence"/>
1554: <p:element name="empty"></p:element>
1555: <p:function name="emptySet"/>
1556: <p:function name="emptySet"/>
1557: </p:judgement>
1558: </p:rule>
1559: </p:proofSystem>
1560:
1561: </section>
1562:
1563:
1564: <section id="text-pattern">
1565: <title><literal>text</literal> pattern</title>
1566:
1567: <para>We use the following additional notation:</para>
1568:
1569: <variablelist>
1570: <varlistentry><term><p:var range="string"/></term><listitem><para>ranges
1571: over strings</para></listitem></varlistentry>
1572: </variablelist>
1573:
1574: <para>The semantics of the <literal>text</literal> pattern are as follows:</para>
1575:
1576: <p:proofSystem>
1577: <p:rule name="text 1">
1578: <p:judgement name="match">
1579: <p:var range="context"/>
1580: <p:function name="emptySet"/>
1581: <p:function name="emptySequence"/>
1582: <p:element name="text"></p:element>
1583: <p:function name="emptySet"/>
1584: <p:function name="emptySet"/>
1585: </p:judgement>
1586: </p:rule>
1587:
1588: <p:rule name="text 2">
1589: <p:judgement name="match">
1590: <p:var range="context"/>
1591: <p:function name="emptySet"/>
1592: <p:var range="mixed"/>
1593: <p:element name="text"></p:element>
1594: <p:function name="emptySet"/>
1595: <p:function name="emptySet"/>
1596: </p:judgement>
1597: <p:judgement name="match">
1598: <p:var range="context"/>
1599: <p:function name="emptySet"/>
1600: <p:function name="append">
1601: <p:var range="mixed"/>
1602: <p:var range="string"/>
1603: </p:function>
1604: <p:element name="text"></p:element>
1605: <p:function name="emptySet"/>
1606: <p:function name="emptySet"/>
1607: </p:judgement>
1608: </p:rule>
1609:
1610: </p:proofSystem>
1611:
1612: <para>The effect of the above rule is that a <literal>text</literal>
1613: element matches zero or more strings.</para>
1614:
1615: </section>
1616:
1617:
1618: <section>
1619: <title><literal>oneOrMore</literal> pattern</title>
1620:
1621: <para>We use the following additional notation:</para>
1622:
1623: <variablelist>
1624: <varlistentry><term><p:judgement name="disjoint">
1625: <p:var range="att" sub="1"/>
1626: <p:var range="att" sub="2"/>
1627: </p:judgement></term><listitem><para>
1628: asserts that there is no name that is
1629: the name of both an attribute in <p:var range="att" sub="1"/>
1630: and of an attribute in <p:var range="att" sub="2"/>
1631: </para></listitem></varlistentry>
1632: </variablelist>
1633:
1634: <para>The semantics of the <literal>oneOrMore</literal> pattern are as follows:</para>
1635:
1636: <p:proofSystem>
1637: <p:rule name="oneOrMore 1">
1638: <p:judgement name="match">
1639: <p:var range="context"/>
1640: <p:var range="att"/>
1641: <p:var range="mixed"/>
1642: <p:var range="pattern"/>
1643: </p:judgement>
1644:
1645: <p:judgement name="match">
1646: <p:var range="context"/>
1647: <p:var range="att"/>
1648: <p:var range="mixed"/>
1649: <p:element name="oneOrMore">
1650: <p:var range="pattern"/>
1651: </p:element>
1652: </p:judgement>
1653: </p:rule>
1654:
1655: <p:rule name="oneOrMore 2">
1656: <p:judgement name="match">
1657: <p:var range="context"/>
1658: <p:var range="att" sub="1"/>
1659: <p:var range="mixed" sub="1"/>
1660: <p:var range="pattern"/>
1661: </p:judgement>
1662:
1663: <p:judgement name="match">
1664: <p:var range="context"/>
1665: <p:var range="att" sub="2"/>
1666: <p:var range="mixed" sub="2"/>
1667: <p:element name="oneOrMore">
1668: <p:var range="pattern"/>
1669: </p:element>
1670: </p:judgement>
1671:
1672: <p:judgement name="disjoint">
1673: <p:var range="att" sub="1"/>
1674: <p:var range="att" sub="2"/>
1675: </p:judgement>
1676:
1677: <p:judgement name="match">
1678: <p:var range="context"/>
1679: <p:function name="union">
1680: <p:var range="att" sub="1"/>
1681: <p:var range="att" sub="2"/>
1682: </p:function>
1683: <p:function name="append">
1684: <p:var range="mixed" sub="1"/>
1685: <p:var range="mixed" sub="2"/>
1686: </p:function>
1687: <p:element name="oneOrMore">
1688: <p:var range="pattern"/>
1689: </p:element>
1690: </p:judgement>
1691: </p:rule>
1692:
1693: </p:proofSystem>
1694:
1695: </section>
1696:
1697:
1698: <section>
1699: <title><literal>interleave</literal> pattern</title>
1700:
1701: <para>We use the following additional notation:</para>
1702:
1703: <variablelist>
1704: <varlistentry><term><p:judgement name="interleave">
1705: <p:var range="mixed" sub="1"/>
1706: <p:var range="mixed" sub="2"/>
1707: <p:var range="mixed" sub="3"/>
1708: </p:judgement></term><listitem><para>
1709:
1710: asserts that <p:var range="mixed" sub="1"/>
1711: is an interleaving of <p:var range="mixed" sub="2"/>
1712: and <p:var range="mixed" sub="3"/>
1713: </para></listitem></varlistentry>
1714:
1715: </variablelist>
1716:
1717: <para>The semantics of interleaving are defined by the following rules.</para>
1718:
1719:
1720: <p:proofSystem>
1721: <p:rule name="interleaves 1">
1722:
1723: <p:judgement name="interleave">
1724: <p:function name="emptySequence"/>
1725: <p:function name="emptySequence"/>
1726: <p:function name="emptySequence"/>
1727: </p:judgement>
1728:
1729: </p:rule>
1730:
1731: <p:rule name="interleaves 2">
1732:
1733: <p:judgement name="interleave">
1734: <p:var range="mixed" sub="1"/>
1735: <p:var range="mixed" sub="2"/>
1736: <p:var range="mixed" sub="3"/>
1737: </p:judgement>
1738:
1739: <p:judgement name="interleave">
1740: <p:function name="append">
1741: <p:var range="mixed" sub="4"/>
1742: <p:var range="mixed" sub="1"/>
1743: </p:function>
1744: <p:function name="append">
1745: <p:var range="mixed" sub="4"/>
1746: <p:var range="mixed" sub="2"/>
1747: </p:function>
1748: <p:var range="mixed" sub="3"/>
1749: </p:judgement>
1750:
1751: </p:rule>
1752:
1753: <p:rule name="interleaves 3">
1754:
1755: <p:judgement name="interleave">
1756: <p:var range="mixed" sub="1"/>
1757: <p:var range="mixed" sub="2"/>
1758: <p:var range="mixed" sub="3"/>
1759: </p:judgement>
1760:
1761: <p:judgement name="interleave">
1762: <p:function name="append">
1763: <p:var range="mixed" sub="4"/>
1764: <p:var range="mixed" sub="1"/>
1765: </p:function>
1766: <p:var range="mixed" sub="2"/>
1767: <p:function name="append">
1768: <p:var range="mixed" sub="4"/>
1769: <p:var range="mixed" sub="3"/>
1770: </p:function>
1771: </p:judgement>
1772:
1773: </p:rule>
1774:
1775: </p:proofSystem>
1776:
1777: <para>For example, the interleavings of
1778: <literal><![CDATA[<a/><a/>]]></literal> and
1779: <literal><![CDATA[<b/>]]></literal> are
1780: <literal><![CDATA[<a/><a/><b/>]]></literal>,
1781: <literal><![CDATA[<a/><b/><a/>]]></literal>, and
1782: <literal><![CDATA[<b/><a/><a/>]]></literal>.</para>
1783:
1784: <para>The semantics of the <literal>interleave</literal> pattern are
1785: as follows:</para>
1786:
1787: <p:proofSystem>
1788: <p:rule name="interleave">
1789:
1790: <p:judgement name="match">
1791: <p:var range="context"/>
1792: <p:var range="att" sub="1"/>
1793: <p:var range="mixed" sub="1"/>
1794: <p:var range="pattern" sub="1"/>
1795: </p:judgement>
1796:
1797: <p:judgement name="match">
1798: <p:var range="context"/>
1799: <p:var range="att" sub="2"/>
1800: <p:var range="mixed" sub="2"/>
1801: <p:var range="pattern" sub="2"/>
1802: </p:judgement>
1803:
1804: <p:judgement name="interleave">
1805: <p:var range="mixed" sub="3"/>
1806: <p:var range="mixed" sub="1"/>
1807: <p:var range="mixed" sub="2"/>
1808: </p:judgement>
1809:
1810:
1811: <p:judgement name="match">
1812: <p:var range="context"/>
1813: <p:function name="union">
1814: <p:var range="att" sub="1"/>
1815: <p:var range="att" sub="2"/>
1816: </p:function>
1817: <p:var range="mixed" sub="3"/>
1818: <p:element name="interleave">
1819: <p:var range="pattern" sub="1"/>
1820: <p:var range="pattern" sub="2"/>
1821: </p:element>
1822: </p:judgement>
1823:
1824: </p:rule>
1825:
1826: </p:proofSystem>
1827:
1828: <note><para>The restriction in <xref linkend="attribute-restrictions"/>
1829: ensures that the set of attributes constructed in the consequent will
1830: not have multiple attributes with the same name.</para></note>
1831:
1832: </section>
1833:
1834: <section id="element-pattern">
1835: <title><literal>element</literal> and <literal>attribute</literal> pattern</title>
1836:
1837: <para>The value of an attribute is always a single string, which may
1838: be empty. Thus, the empty sequence is not a possible attribute value.
1839: On the hand, the children of an element can be an empty sequence and
1840: cannot consist of an empty string. In order to ensure that validation
1841: handles attributes and elements consistently, we introduce a variant
1842: of matching called <firstterm>weak matching</firstterm>. Weak
1843: matching is used when matching the pattern for the value of an
1844: attribute or for the attributes and children of an element. We use
1845: the following notation to define weak matching.</para>
1846:
1847: <variablelist>
1848:
1849: <varlistentry><term><p:function
1850: name="emptyString"/></term><listitem><para>represents an empty
1851: string</para></listitem></varlistentry>
1852:
1853: <varlistentry><term><p:var
1854: range="whiteSpace"/></term><listitem><para>ranges over the empty
1855: sequence and strings that consist entirely of
1856: whitespace</para></listitem></varlistentry>
1857:
1858: <varlistentry><term><p:judgement name="weakMatch">
1859: <p:var range="context"/>
1860: <p:var range="att"/>
1861: <p:var range="mixed"/>
1862: <p:var range="pattern"/>
1863: </p:judgement></term><listitem><para>
1864:
1865: asserts that with respect to context <p:var range="context"/>, the
1866: attributes <p:var range="att"/> and the sequence of elements and
1867: strings <p:var range="mixed"/> weakly matches the pattern <p:var
1868: range="pattern"/></para></listitem></varlistentry>
1869:
1870: </variablelist>
1871:
1872: <para>The semantics of weak matching are as follows:</para>
1873:
1874: <p:proofSystem>
1875: <p:rule name="weak match 1">
1876: <p:judgement name="match">
1877: <p:var range="context"/>
1878: <p:var range="att"/>
1879: <p:var range="mixed"/>
1880: <p:var range="pattern"/>
1881: </p:judgement>
1882: <p:judgement name="weakMatch">
1883: <p:var range="context"/>
1884: <p:var range="att"/>
1885: <p:var range="mixed"/>
1886: <p:var range="pattern"/>
1887: </p:judgement>
1888: </p:rule>
1889: <p:rule name="weak match 2">
1890: <p:judgement name="match">
1891: <p:var range="context"/>
1892: <p:var range="att"/>
1893: <p:function name="emptySequence"/>
1894: <p:var range="pattern"/>
1895: </p:judgement>
1896: <p:judgement name="weakMatch">
1897: <p:var range="context"/>
1898: <p:var range="att"/>
1899: <p:var range="whiteSpace"/>
1900: <p:var range="pattern"/>
1901: </p:judgement>
1902: </p:rule>
1903: <p:rule name="weak match 3">
1904: <p:judgement name="match">
1905: <p:var range="context"/>
1906: <p:var range="att"/>
1907: <p:function name="emptyString"/>
1908: <p:var range="pattern"/>
1909: </p:judgement>
1910: <p:judgement name="weakMatch">
1911: <p:var range="context"/>
1912: <p:var range="att"/>
1913: <p:function name="emptySequence"/>
1914: <p:var range="pattern"/>
1915: </p:judgement>
1916: </p:rule>
1917: </p:proofSystem>
1918:
1919: <para>We use the following additional notation:</para>
1920:
1921: <variablelist>
1922:
1923: <varlistentry><term><p:function name="attribute">
1924: <p:var range="name"/>
1925: <p:var range="string"/>
1926: </p:function></term><listitem><para>
1927:
1928: constructs an attribute with name <p:var range="name"/>
1929: and value <p:var range="string"/>
1930: </para></listitem></varlistentry>
1931:
1932: <varlistentry><term><p:function name="element">
1933: <p:var range="name"/>
1934: <p:var range="context"/>
1935: <p:var range="att"/>
1936: <p:var range="mixed"/>
1937: </p:function></term><listitem><para>
1938:
1939: constructs an element with name <p:var range="name"/>,
1940: context <p:var range="context"/>,
1941: attributes <p:var range="att"/>
1942: and mixed sequence <p:var range="mixed"/> as children
1943: </para></listitem></varlistentry>
1944:
1945: <varlistentry><term><p:judgement name="okAsChildren">
1946: <p:var range="mixed"/>
1947: </p:judgement></term><listitem><para>
1948:
1949: asserts that the mixed sequence <p:var range="mixed"/> can occur as
1950: the children of an element: it does not contain any member that is an
1951: empty string, nor does it contain two consecutive members that are
1952: both strings</para></listitem></varlistentry>
1953:
1954: <varlistentry><term><p:judgement name="bind">
1955: <p:var range="ncname"/>
1956: <p:var range="nameClass"/>
1957: <p:var range="pattern"/>
1958: </p:judgement></term><listitem><para>
1959:
1960: asserts that the grammar contains
1961: <p:element name="define">
1962: <p:attribute name="name">
1963: <p:var range="ncname"/>
1964: </p:attribute>
1965: <p:element name="element">
1966: <p:var range="nameClass"/>
1967: <p:var range="pattern"/>
1968: </p:element>
1969: </p:element>
1970: </para></listitem></varlistentry>
1971:
1972: </variablelist>
1973:
1974: <para>The semantics of the <literal>attribute</literal> pattern are as follows:</para>
1975:
1976: <p:proofSystem>
1977: <p:rule name="attribute">
1978:
1979: <p:judgement name="weakMatch">
1980: <p:var range="context"/>
1981: <p:function name="emptySet"/>
1982: <p:var range="string"/>
1983: <p:var range="pattern"/>
1984: </p:judgement>
1985:
1986: <p:judgement name="belongs">
1987: <p:var range="name"/>
1988: <p:var range="nameClass"/>
1989: </p:judgement>
1990:
1991: <p:judgement name="match">
1992: <p:var range="context"/>
1993: <p:function name="attribute">
1994: <p:var range="name"/>
1995: <p:var range="string"/>
1996: </p:function>
1997: <p:function name="emptySequence"/>
1998: <p:element name="attribute">
1999: <p:var range="nameClass"/>
2000: <p:var range="pattern"/>
2001: </p:element>
2002: </p:judgement>
2003:
2004: </p:rule>
2005:
2006: </p:proofSystem>
2007:
2008: <para>The semantics of the <literal>element</literal> pattern are as follows:</para>
2009:
2010: <p:proofSystem>
2011: <p:rule name="element">
2012:
2013: <p:judgement name="weakMatch">
2014: <p:var range="context" sub="1"/>
2015: <p:var range="att"/>
2016: <p:var range="mixed"/>
2017: <p:var range="pattern"/>
2018: </p:judgement>
2019:
2020: <p:judgement name="belongs">
2021: <p:var range="name"/>
2022: <p:var range="nameClass"/>
2023: </p:judgement>
2024:
2025: <p:judgement name="okAsChildren">
2026: <p:var range="mixed"/>
2027: </p:judgement>
2028:
2029: <p:judgement name="bind">
2030: <p:var range="ncname"/>
2031: <p:var range="nameClass"/>
2032: <p:var range="pattern"/>
2033: </p:judgement>
2034:
2035: <p:judgement name="match">
2036: <p:var range="context" sub="2"/>
2037: <p:function name="emptySet"/>
2038: <p:function name="append">
2039: <p:var range="whiteSpace" sub="1"/>
2040: <p:function name="element">
2041: <p:var range="name"/>
2042: <p:var range="context" sub="1"/>
2043: <p:var range="att"/>
2044: <p:var range="mixed"/>
2045: </p:function>
2046: <p:var range="whiteSpace" sub="2"/>
2047: </p:function>
2048: <p:element name="ref">
2049: <p:attribute name="name">
2050: <p:var range="ncname"/>
2051: </p:attribute>
2052: </p:element>
2053: </p:judgement>
2054:
2055: </p:rule>
2056:
2057: </p:proofSystem>
2058:
2059:
2060: </section>
2061:
2062: <section id="data-pattern">
2063: <title><literal>data</literal> and <literal>value</literal> pattern</title>
2064:
2065: <para>RELAX NG relies on datatype libraries to perform datatyping.
2066: A datatype library is identified by a URI. A datatype within a
2067: datatype library is identified by an NCName. A datatype library
2068: provides two services.</para>
2069:
2070: <itemizedlist>
2071:
2072: <listitem><para>It can determine whether a string is a legal
2073: representation of a datatype. This service accepts a list of zero or
2074: more parameters. For example, a string datatype might have a parameter
2075: specifying the length of a string. The datatype library determines
2076: what parameters are applicable for each datatype.</para></listitem>
2077:
2078: <listitem><para>It can determine whether two strings represent the
2079: same value of a datatype. This service does not have any
2080: parameters.</para></listitem>
2081:
2082: </itemizedlist>
2083:
2084: <para>Both services may make use of the context of a string. For
2085: example, a datatype representing a QName would use the namespace
2086: map.</para>
2087:
2088: <para>We use the following additional notation:</para>
2089:
2090: <variablelist>
2091: <varlistentry><term><p:judgement name="datatypeAllows">
2092: <p:var range="uri"/>
2093: <p:var range="ncname"/>
2094: <p:var range="params"/>
2095: <p:var range="string"/>
2096: <p:var range="context"/>
2097: </p:judgement></term><listitem><para>
2098:
2099: asserts that in the datatype library identified by URI <p:var range="uri"/>, the string <p:var range="string"/> interpreted with
2100: context <p:var range="context"/> is a legal
2101: value of datatype <p:var range="ncname"/> with parameters <p:var range="params"/></para></listitem></varlistentry>
2102:
2103: <varlistentry><term><p:judgement name="datatypeEqual">
2104: <p:var range="uri"/>
2105: <p:var range="ncname"/>
2106: <p:var range="string" sub="1"/>
2107: <p:var range="context" sub="1"/>
2108: <p:var range="string" sub="2"/>
2109: <p:var range="context" sub="2"/>
2110: </p:judgement></term><listitem><para>
2111:
2112: asserts that in the datatype library identified by URI <p:var range="uri"/>, string <p:var range="string" sub="1"/> interpreted with
2113: context <p:var range="context" sub="1"/> represents the same value of
2114: the datatype <p:var range="ncname"/> as the string <p:var range="string" sub="2"/> interpreted in the context of <p:var range="context" sub="2"/>
2115: </para></listitem></varlistentry>
2116:
2117: <varlistentry><term><p:var range="params"/></term><listitem><para>ranges over sequences of parameters</para></listitem></varlistentry>
2118:
2119: <varlistentry><term><p:context>
2120: <p:var range="context"/>
2121: </p:context></term><listitem><para>
2122:
2123: within the start-tag of a pattern refers to the context
2124: of the pattern element
2125: </para></listitem></varlistentry>
2126:
2127: <varlistentry>
2128: <term>
2129: <p:function name="context">
2130: <p:var range="uri"/>
2131: <p:var range="context"/>
2132: </p:function>
2133: </term>
2134: <listitem><para>constructs a context which is the same as <p:var range="context"/>
2135: except that the default namespace is <p:var range="uri"/>; if <p:var
2136: range="uri"/> is the empty string, then there is no default namespace
2137: in the constructed context</para></listitem></varlistentry>
2138:
2139: </variablelist>
2140:
2141: <para>The datatypeEqual function must be reflexive, transitive
2142: and symmetric, that is, the following inference rules must hold:</para>
2143:
2144: <p:proofSystem>
2145: <p:rule name="datatypeEqual reflexive">
2146: <p:judgement name="datatypeAllows">
2147: <p:var range="uri"/>
2148: <p:var range="ncname"/>
2149: <p:var range="params"/>
2150: <p:var range="string"/>
2151: <p:var range="context"/>
2152: </p:judgement>
2153: <p:judgement name="datatypeEqual">
2154: <p:var range="uri"/>
2155: <p:var range="ncname"/>
2156: <p:var range="string"/>
2157: <p:var range="context"/>
2158: <p:var range="string"/>
2159: <p:var range="context"/>
2160: </p:judgement>
2161: </p:rule>
2162: <p:rule name="datatypeEqual transitive">
2163: <p:judgement name="datatypeEqual">
2164: <p:var range="uri"/>
2165: <p:var range="ncname"/>
2166: <p:var range="string" sub="1"/>
2167: <p:var range="context" sub="1"/>
2168: <p:var range="string" sub="2"/>
2169: <p:var range="context" sub="2"/>
2170: </p:judgement>
2171: <p:judgement name="datatypeEqual">
2172: <p:var range="uri"/>
2173: <p:var range="ncname"/>
2174: <p:var range="string" sub="2"/>
2175: <p:var range="context" sub="3"/>
2176: <p:var range="string" sub="3"/>
2177: <p:var range="context" sub="3"/>
2178: </p:judgement>
2179: <p:judgement name="datatypeEqual">
2180: <p:var range="uri"/>
2181: <p:var range="ncname"/>
2182: <p:var range="string" sub="1"/>
2183: <p:var range="context" sub="1"/>
2184: <p:var range="string" sub="3"/>
2185: <p:var range="context" sub="3"/>
2186: </p:judgement>
2187: </p:rule>
2188: <p:rule name="datatypeEqual symmetric">
2189: <p:judgement name="datatypeEqual">
2190: <p:var range="uri"/>
2191: <p:var range="ncname"/>
2192: <p:var range="string" sub="1"/>
2193: <p:var range="context" sub="1"/>
2194: <p:var range="string" sub="2"/>
2195: <p:var range="context" sub="2"/>
2196: </p:judgement>
2197: <p:judgement name="datatypeEqual">
2198: <p:var range="uri"/>
2199: <p:var range="ncname"/>
2200: <p:var range="string" sub="2"/>
2201: <p:var range="context" sub="2"/>
2202: <p:var range="string" sub="1"/>
2203: <p:var range="context" sub="1"/>
2204: </p:judgement>
2205: </p:rule>
2206: </p:proofSystem>
2207:
2208: <para>The semantics of the <literal>data</literal> and
2209: <literal>value</literal> patterns are as follows:</para>
2210:
2211: <p:proofSystem>
2212: <p:rule name="value">
2213: <p:judgement name="datatypeEqual">
2214: <p:var range="uri" sub="1"/>
2215: <p:var range="ncname"/>
2216: <p:var range="string" sub="1"/>
2217: <p:var range="context" sub="1"/>
2218: <p:var range="string" sub="2"/>
2219: <p:function name="context">
2220: <p:var range="uri" sub="2"/>
2221: <p:var range="context" sub="2"/>
2222: </p:function>
2223: </p:judgement>
2224: <p:judgement name="match">
2225: <p:var range="context" sub="1"/>
2226: <p:function name="emptySet"/>
2227: <p:var range="string" sub="1"/>
2228: <p:element name="value">
2229: <p:attribute name="datatypeLibrary">
2230: <p:var range="uri" sub="1"/>
2231: </p:attribute>
2232: <p:attribute name="type">
2233: <p:var range="ncname"/>
2234: </p:attribute>
2235: <p:attribute name="ns">
2236: <p:var range="uri" sub="2"/>
2237: </p:attribute>
2238: <p:context>
2239: <p:var range="context" sub="2"/>
2240: </p:context>
2241: <p:var range="string" sub="2"/>
2242: </p:element>
2243: <p:function name="emptySet"/>
2244: <p:function name="emptySet"/>
2245: </p:judgement>
2246: </p:rule>
2247:
2248: <p:rule name="data 1">
2249: <p:judgement name="datatypeAllows">
2250: <p:var range="uri"/>
2251: <p:var range="ncname"/>
2252: <p:var range="params"/>
2253: <p:var range="string"/>
2254: <p:var range="context"/>
2255: </p:judgement>
2256: <p:judgement name="match">
2257: <p:var range="context"/>
2258: <p:function name="emptySet"/>
2259: <p:var range="string"/>
2260: <p:element name="data">
2261: <p:attribute name="datatypeLibrary">
2262: <p:var range="uri"/>
2263: </p:attribute>
2264: <p:attribute name="type">
2265: <p:var range="ncname"/>
2266: </p:attribute>
2267: <p:var range="params"/>
2268: </p:element>
2269: <p:function name="emptySet"/>
2270: <p:function name="emptySet"/>
2271: </p:judgement>
2272: </p:rule>
2273:
2274: <p:rule name="data 2">
2275: <p:judgement name="datatypeAllows">
2276: <p:var range="uri"/>
2277: <p:var range="ncname"/>
2278: <p:var range="params"/>
2279: <p:var range="string"/>
2280: <p:var range="context"/>
2281: </p:judgement>
2282: <p:not>
2283: <p:judgement name="match">
2284: <p:var range="context"/>
2285: <p:var range="att"/>
2286: <p:var range="string"/>
2287: <p:var range="pattern"/>
2288: </p:judgement>
2289: </p:not>
2290: <p:judgement name="match">
2291: <p:var range="context"/>
2292: <p:function name="emptySet"/>
2293: <p:var range="string"/>
2294: <p:element name="data">
2295: <p:attribute name="datatypeLibrary">
2296: <p:var range="uri"/>
2297: </p:attribute>
2298: <p:attribute name="type">
2299: <p:var range="ncname"/>
2300: </p:attribute>
2301: <p:var range="params"/>
2302: <p:element name="except">
2303: <p:var range="pattern"/>
2304: </p:element>
2305: </p:element>
2306: <p:function name="emptySet"/>
2307: <p:function name="emptySet"/>
2308: </p:judgement>
2309: </p:rule>
2310:
2311: </p:proofSystem>
2312:
2313: </section>
2314:
2315: <section id="built-in-datatype">
2316: <title>Built-in datatype library</title>
2317:
2318: <para>The empty URI identifies a special built-in datatype library.
2319: This provides two datatypes, <literal>string</literal> and
2320: <literal>token</literal>. No parameters are allowed for either of
2321: these datatypes.</para>
2322:
2323: <variablelist>
2324: <varlistentry><term>
2325: <p:judgement name="equal">
2326: <p:var range="string" sub="1"/>
2327: <p:var range="string" sub="2"/>
2328: </p:judgement></term>
2329: <listitem><para>asserts that <p:var range="string" sub="1"/>
2330: and <p:var range="string" sub="2"/> are identical</para></listitem>
2331: </varlistentry>
2332:
2333: <varlistentry><term>
2334: <p:function name="normalizeWhiteSpace">
2335: <p:var range="string"/>
2336: </p:function>
2337: </term>
2338: <listitem><para>returns the string <p:var range="string"/>,
2339: with leading and trailing whitespace characters removed,
2340: and with each other maximal sequence of whitespace characters
2341: replaced by a single space character </para></listitem>
2342: </varlistentry>
2343: </variablelist>
2344:
2345: <para>The semantics of the two built-in datatypes are as
2346: follows:</para>
2347:
2348: <p:proofSystem>
2349:
2350: <p:rule name="string allows">
2351: <p:judgement name="datatypeAllows">
2352: <p:function name="emptyString"/>
2353: <p:string>string</p:string>
2354: <p:function name="emptySequence"/>
2355: <p:var range="string"/>
2356: <p:var range="context"/>
2357: </p:judgement>
2358: </p:rule>
2359:
2360: <p:rule name="string equal">
2361: <p:judgement name="datatypeEqual">
2362: <p:function name="emptyString"/>
2363: <p:string>string</p:string>
2364: <p:var range="string"/>
2365: <p:var range="context" sub="1"/>
2366: <p:var range="string"/>
2367: <p:var range="context" sub="2"/>
2368: </p:judgement>
2369: </p:rule>
2370:
2371: <p:rule name="token allows">
2372: <p:judgement name="datatypeAllows">
2373: <p:function name="emptyString"/>
2374: <p:string>token</p:string>
2375: <p:function name="emptySequence"/>
2376: <p:var range="string"/>
2377: <p:var range="context"/>
2378: </p:judgement>
2379: </p:rule>
2380:
2381: <p:rule name="token equal">
2382: <p:judgement name="equal">
2383: <p:function name="normalizeWhiteSpace">
2384: <p:var range="string" sub="1"/>
2385: </p:function>
2386: <p:function name="normalizeWhiteSpace">
2387: <p:var range="string" sub="2"/>
2388: </p:function>
2389: </p:judgement>
2390: <p:judgement name="datatypeEqual">
2391: <p:function name="emptyString"/>
2392: <p:string>token</p:string>
2393: <p:var range="string" sub="1"/>
2394: <p:var range="context" sub="1"/>
2395: <p:var range="string" sub="2"/>
2396: <p:var range="context" sub="2"/>
2397: </p:judgement>
2398: </p:rule>
2399:
2400: </p:proofSystem>
2401:
2402: </section>
2403:
2404: <section>
2405: <title><literal>list</literal> pattern</title>
2406:
2407: <para>We use the following additional notation:</para>
2408:
2409: <variablelist>
2410: <varlistentry><term><p:function name="split">
2411: <p:var range="string"/>
2412: </p:function></term><listitem><para>
2413:
2414: returns a sequence of strings one for each whitespace delimited token
2415: of <p:var range="string"/>; each string in the returned sequence will
2416: be non-empty and will not contain any
2417: whitespace</para></listitem></varlistentry>
2418:
2419: </variablelist>
2420:
2421: <para>The semantics of the <literal>list</literal> pattern are as follows:</para>
2422:
2423: <p:proofSystem>
2424: <p:rule name="list">
2425:
2426: <p:judgement name="match">
2427: <p:var range="context"/>
2428: <p:function name="emptySet"/>
2429: <p:function name="split">
2430: <p:var range="string"/>
2431: </p:function>
2432: <p:var range="pattern"/>
2433: </p:judgement>
2434:
2435: <p:judgement name="match">
2436: <p:var range="context"/>
2437: <p:function name="emptySet"/>
2438: <p:var range="string"/>
2439: <p:element name="list">
2440: <p:var range="pattern"/>
2441: </p:element>
2442: </p:judgement>
2443:
2444: </p:rule>
2445: </p:proofSystem>
2446:
2447: <note><para>It is crucial in the above inference rule that the
2448: sequence that is matched against a pattern can contain consecutive
2449: strings.</para></note>
2450:
2451: </section>
2452:
2453: </section>
2454:
2455: <section id="validity">
2456: <title>Validity</title>
2457:
2458: <para>Now we can define when an element is valid with respect to a
2459: schema. We use the following additional notation:</para>
2460:
2461: <variablelist>
2462:
2463: <varlistentry><term><p:var range="element"/></term><listitem><para>ranges over elements</para></listitem></varlistentry>
2464:
2465: <varlistentry><term><p:judgement name="valid">
2466: <p:var range="element"/>
2467: </p:judgement></term><listitem><para>
2468:
2469: asserts that the element <p:var range="element"/> is valid with
2470: respect to the grammar</para></listitem></varlistentry>
2471:
2472: <varlistentry><term><p:judgement name="start">
2473: <p:var range="pattern"/>
2474: </p:judgement></term><listitem><para>
2475: asserts that the grammar contains
2476: <p:element name="start"><p:var range="pattern"/> </p:element></para></listitem></varlistentry>
2477:
2478: </variablelist>
2479:
2480: <para>An element is valid if together with an empty set of attributes
2481: it matches the <literal>start</literal> pattern of the grammar.</para>
2482:
2483: <p:proofSystem>
2484: <p:rule name="valid">
2485: <p:judgement name="start">
2486: <p:var range="pattern"/>
2487: </p:judgement>
2488: <p:judgement name="match">
2489: <p:var range="context"/>
2490: <p:function name="emptySet"/>
2491: <p:var range="element"/>
2492: <p:var range="pattern"/>
2493: </p:judgement>
2494: <p:judgement name="valid">
2495: <p:var range="element"/>
2496: </p:judgement>
2497: </p:rule>
2498:
2499:
2500: </p:proofSystem>
2501:
2502: </section>
2503:
2504: <section>
2505: <title>Example</title>
2506:
2507: <para>Let <p:var range="element" sub="0"/> be</para>
2508:
2509: <p:formula>
2510:
2511: <p:function name="element">
2512: <p:function name="name">
2513: <p:function name="emptyString"/>
2514: <p:string>foo</p:string>
2515: </p:function>
2516: <p:var range="context" sub="0"/>
2517: <p:function name="emptySet"/>
2518: <p:var range="mixed"/>
2519: </p:function>
2520:
2521: </p:formula>
2522:
2523: <para>where <p:var range="mixed"/> is</para>
2524:
2525: <p:formula>
2526: <p:function name="append">
2527: <p:var range="element" sub="1"/>
2528: <p:var range="element" sub="2"/>
2529: </p:function>
2530: </p:formula>
2531:
2532: <para>and <p:var range="element" sub="1"/> is</para>
2533:
2534: <p:formula>
2535: <p:function name="element">
2536: <p:function name="name">
2537: <p:string>http://www.example.com/n1</p:string>
2538: <p:string>bar1</p:string>
2539: </p:function>
2540: <p:var range="context" sub="1"/>
2541: <p:function name="emptySet"/>
2542: <p:function name="emptySequence"/>
2543: </p:function>
2544: </p:formula>
2545:
2546: <para>and <p:var range="element" sub="2"/> is</para>
2547:
2548: <p:formula>
2549: <p:function name="element">
2550: <p:function name="name">
2551: <p:string>http://www.example.com/n2</p:string>
2552: <p:string>bar2</p:string>
2553: </p:function>
2554: <p:var range="context" sub="2"/>
2555: <p:function name="emptySet"/>
2556: <p:function name="emptySequence"/>
2557: </p:function>
2558: </p:formula>
2559:
2560: <para>Assuming appropriate definitions of <p:var range="context"
2561: sub="0"/>, <p:var range="context" sub="1"/> and <p:var range="context"
2562: sub="2"/>, this represents the document in <xref
2563: linkend="data-model-example"/>.</para>
2564:
2565: <para>We now show how <p:var range="element" sub="0"/> can be shown to
2566: be valid with respect to the schema in <xref
2567: linkend="simple-syntax-example"/>. The schema is equivalent to the
2568: following propositions:</para>
2569:
2570: <p:formula>
2571: <p:judgement name="start">
2572: <p:element name="ref">
2573: <p:attribute name="name"><p:string>foo</p:string></p:attribute>
2574: </p:element>
2575: </p:judgement>
2576: </p:formula>
2577:
2578: <p:formula>
2579: <p:judgement name="bind">
2580: <p:string>foo.element</p:string>
2581: <p:element name="name">
2582: <p:attribute name="ns"><p:function name="emptyString"/></p:attribute>
2583: <p:string>foo</p:string>
2584: </p:element>
2585: <p:element name="group">
2586: <p:element name="ref">
2587: <p:attribute name="name">
2588: <p:string>bar1</p:string>
2589: </p:attribute>
2590: </p:element>
2591: <p:element name="ref">
2592: <p:attribute name="name">
2593: <p:string>bar2</p:string>
2594: </p:attribute>
2595: </p:element>
2596: </p:element>
2597: </p:judgement>
2598: </p:formula>
2599:
2600: <p:formula>
2601: <p:judgement name="bind">
2602: <p:string>bar1.element</p:string>
2603: <p:element name="name">
2604: <p:attribute name="ns">
2605: <p:string>http://www.example.com/n1</p:string>
2606: </p:attribute>
2607: <p:string>bar1</p:string>
2608: </p:element>
2609: <p:element name="empty"/>
2610: </p:judgement>
2611: </p:formula>
2612:
2613: <p:formula>
2614: <p:judgement name="bind">
2615: <p:string>bar2.element</p:string>
2616: <p:element name="name">
2617: <p:attribute name="ns">
2618: <p:string>http://www.example.com/n2</p:string>
2619: </p:attribute>
2620: <p:string>bar2</p:string>
2621: </p:element>
2622: <p:element name="empty"/>
2623: </p:judgement>
2624: </p:formula>
2625:
2626:
2627: <para>Let name class <p:var range="nameClass" sub="1"/> be</para>
2628:
2629: <p:formula>
2630: <p:element name="name">
2631: <p:attribute name="ns">
2632: <p:string>http://www.example.com/n1</p:string>
2633: </p:attribute>
2634: <p:string>bar1</p:string>
2635: </p:element>
2636: </p:formula>
2637:
2638: <para>and let <p:var range="nameClass" sub="2"/> be</para>
2639:
2640: <p:formula>
2641: <p:element name="name">
2642: <p:attribute name="ns">
2643: <p:string>http://www.example.com/n2</p:string>
2644: </p:attribute>
2645: <p:string>bar2</p:string>
2646: </p:element>
2647: </p:formula>
2648:
2649: <para>Then, by the inference rule (name) in <xref
2650: linkend="name-classes"/>, we have</para>
2651:
2652: <p:formula>
2653: <p:judgement name="belongs">
2654: <p:function name="name">
2655: <p:string>http://www.example.com/n1</p:string>
2656: <p:string>bar1</p:string>
2657: </p:function>
2658: <p:var range="nameClass" sub="1"/>
2659: </p:judgement>
2660: </p:formula>
2661:
2662: <para>and</para>
2663:
2664: <p:formula>
2665: <p:judgement name="belongs">
2666: <p:function name="name">
2667: <p:string>http://www.example.com/n2</p:string>
2668: <p:string>bar2</p:string>
2669: </p:function>
2670: <p:var range="nameClass" sub="2"/>
2671: </p:judgement>
2672: </p:formula>
2673:
2674:
2675: <para>By the inference rule (empty) in <xref linkend="empty-pattern"/>,
2676: we have</para>
2677:
2678: <p:formula>
2679: <p:judgement name="match">
2680: <p:var range="context" sub="1"/>
2681: <p:function name="emptySet"/>
2682: <p:function name="emptySequence"/>
2683: <p:element name="empty"></p:element>
2684: </p:judgement>
2685: </p:formula>
2686:
2687: <para>and</para>
2688:
2689: <p:formula>
2690: <p:judgement name="match">
2691: <p:var range="context" sub="2"/>
2692: <p:function name="emptySet"/>
2693: <p:function name="emptySequence"/>
2694: <p:element name="empty"></p:element>
2695: </p:judgement>
2696: </p:formula>
2697:
2698: <para>Thus by the inference rule (element) in <xref
2699: linkend="element-pattern"/>, we have</para>
2700:
2701: <p:formula>
2702: <p:judgement name="match">
2703: <p:var range="context" sub="0"/>
2704: <p:function name="emptySet"/>
2705: <p:var range="element" sub="1"/>
2706: <p:element name="ref">
2707: <p:attribute name="name">
2708: <p:string>bar1</p:string>
2709: </p:attribute>
2710: </p:element>
2711: </p:judgement>
2712: </p:formula>
2713:
2714: <para>Note that we have chosen <p:var
2715: range="context" sub="0"/>, since any context is allowed.</para>
2716:
2717: <para>Likewise, we have</para>
2718:
2719: <p:formula>
2720: <p:judgement name="match">
2721: <p:var range="context" sub="0"/>
2722: <p:function name="emptySet"/>
2723: <p:var range="element" sub="2"/>
2724: <p:element name="ref">
2725: <p:attribute name="name">
2726: <p:string>bar2</p:string>
2727: </p:attribute>
2728: </p:element>
2729: </p:judgement>
2730: </p:formula>
2731:
2732: <para>By the inference rule (group) in <xref
2733: linkend="choice-pattern"/>, we have</para>
2734:
2735: <p:formula>
2736: <p:judgement name="match">
2737: <p:var range="context" sub="0"/>
2738: <p:function name="emptySet"/>
2739: <p:function name="append">
2740: <p:var range="element" sub="1"/>
2741: <p:var range="element" sub="2"/>
2742: </p:function>
2743: <p:element name="group">
2744: <p:element name="ref">
2745: <p:attribute name="name">
2746: <p:string>bar1</p:string>
2747: </p:attribute>
2748: </p:element>
2749: <p:element name="ref">
2750: <p:attribute name="name">
2751: <p:string>bar2</p:string>
2752: </p:attribute>
2753: </p:element>
2754: </p:element>
2755: </p:judgement>
2756: </p:formula>
2757:
2758: <para>By the inference rule (element) in <xref
2759: linkend="element-pattern"/>, we have</para>
2760:
2761: <p:formula>
2762: <p:judgement name="match">
2763: <p:var range="context" sub="3"/>
2764: <p:function name="emptySet"/>
2765: <p:function name="element">
2766: <p:function name="name">
2767: <p:function name="emptyString"/>
2768: <p:string>foo</p:string>
2769: </p:function>
2770: <p:var range="context" sub="0"/>
2771: <p:function name="emptySet"/>
2772: <p:var range="mixed"/>
2773: </p:function>
2774: <p:element name="ref">
2775: <p:attribute name="name">
2776: <p:string>foo</p:string>
2777: </p:attribute>
2778: </p:element>
2779: </p:judgement>
2780: </p:formula>
2781:
2782: <para>Here <p:var range="context" sub="3"/> is an arbitrary
2783: context.</para>
2784:
2785: <para>Thus we can apply the inference rule (valid) in <xref
2786: linkend="validity"/> and obtain</para>
2787:
2788: <p:formula>
2789: <p:judgement name="valid">
2790: <p:var range="element" sub="0"/>
2791: </p:judgement>
2792: </p:formula>
2793:
2794: </section>
2795:
2796: </section>
2797:
2798: <section id="restriction">
2799: <title>Restrictions</title>
2800:
2801: <para>The following constraints are all checked after the grammar has
2802: been transformed to the simple form described in <xref
2803: linkend="simple-syntax"/>. The purpose of these restrictions is to
2804: catch user errors and to facilitate implementation.</para>
2805:
2806: <section id="contextual-restriction">
2807: <title>Contextual restrictions</title>
2808:
2809: <para>In this section we describe restrictions on where elements are
2810: allowed in the schema based on the names of the ancestor elements. We
2811: use the concept of a <firstterm>prohibited path</firstterm> to
2812: describe these restrictions. A path is a sequence of NCNames separated
2813: by <literal>/</literal> or <literal>//</literal>.</para>
2814:
2815: <itemizedlist>
2816:
2817: <listitem><para>An element matches a path
2818: <replaceable>x</replaceable>, where <replaceable>x</replaceable> is an
2819: NCName, if and only if the local name of the element is
2820: <replaceable>x</replaceable></para></listitem>
2821:
2822: <listitem><para>An element matches a path
2823: <replaceable>x</replaceable><literal>/</literal><replaceable>p</replaceable>,
2824: where <replaceable>x</replaceable> is an NCName and
2825: <replaceable>p</replaceable> is a path, if and only if the local name
2826: of the element is <replaceable>x</replaceable> and the element has a
2827: child that matches <replaceable>p</replaceable></para></listitem>
2828:
2829: <listitem><para>An element matches a path
2830: <replaceable>x</replaceable><literal>//</literal><replaceable>p</replaceable>,
2831: where <replaceable>x</replaceable> is an NCName and
2832: <replaceable>p</replaceable> is a path, if and only if the local name
2833: of the element is <replaceable>x</replaceable> and the element has a
2834: descendant that matches <replaceable>p</replaceable></para></listitem>
2835:
2836: </itemizedlist>
2837:
2838: <para>For example, the element</para>
2839:
2840: <programlisting><![CDATA[<foo>
2841: <bar>
2842: <baz/>
2843: </bar>
2844: </foo>]]></programlisting>
2845:
2846: <para>matches the paths <literal>foo</literal>,
2847: <literal>foo/bar</literal>, <literal>foo//bar</literal>,
2848: <literal>foo//baz</literal>, <literal>foo/bar/baz</literal>,
2849: <literal>foo/bar//baz</literal> and <literal>foo//bar/baz</literal>,
2850: but not <literal>foo/baz</literal> or
2851: <literal>foobar</literal>.</para>
2852:
2853: <para>A correct RELAX NG schema must be such that, after
2854: transformation to the simple form, it does not contain any element
2855: that matches a prohibited path.</para>
2856:
2857: <section>
2858: <title><literal>attribute</literal> pattern</title>
2859:
2860: <para>The following paths are prohibited:</para>
2861:
2862: <itemizedlist>
2863: <listitem><para><literal>attribute//ref</literal></para></listitem>
2864: <listitem><para><literal>attribute//attribute</literal></para></listitem>
2865: </itemizedlist>
2866:
2867: </section>
2868:
2869: <section>
2870: <title><literal>oneOrMore</literal> pattern</title>
2871:
2872: <para>The following paths are prohibited:</para>
2873:
2874: <itemizedlist>
2875: <listitem><para><literal>oneOrMore//group//attribute</literal></para></listitem>
2876: <listitem><para><literal>oneOrMore//interleave//attribute</literal></para></listitem>
2877: </itemizedlist>
2878:
2879: </section>
2880:
2881: <section id="list-restrictions">
2882: <title><literal>list</literal> pattern</title>
2883:
2884: <para>The following paths are prohibited:</para>
2885:
2886: <itemizedlist>
2887: <listitem><para><literal>list//list</literal></para></listitem>
2888: <listitem><para><literal>list//ref</literal></para></listitem>
2889: <listitem><para><literal>list//attribute</literal></para></listitem>
2890: <listitem><para><literal>list//text</literal></para></listitem>
2891: <listitem><para><literal>list//interleave</literal></para></listitem>
2892: </itemizedlist>
2893: </section>
2894:
2895: <section id="context-data-except">
2896: <title><literal>except</literal> in <literal>data</literal> pattern</title>
2897:
2898: <para>The following paths are prohibited:</para>
2899:
2900: <itemizedlist>
2901: <listitem><para><literal>data/except//attribute</literal></para></listitem>
2902: <listitem><para><literal>data/except//ref</literal></para></listitem>
2903: <listitem><para><literal>data/except//text</literal></para></listitem>
2904: <listitem><para><literal>data/except//list</literal></para></listitem>
2905: <listitem><para><literal>data/except//group</literal></para></listitem>
2906: <listitem><para><literal>data/except//interleave</literal></para></listitem>
2907: <listitem><para><literal>data/except//oneOrMore</literal></para></listitem>
2908: <listitem><para><literal>data/except//empty</literal></para></listitem>
2909: </itemizedlist>
2910:
2911: <note><para>This implies that an <literal>except</literal> element
2912: with a <literal>data</literal> parent can contain only
2913: <literal>data</literal>, <literal>value</literal> and
2914: <literal>choice</literal> elements.</para></note>
2915:
2916: </section>
2917:
2918: <section id="context-start">
2919: <title><literal>start</literal> element</title>
2920:
2921: <para>The following paths are prohibited:</para>
2922:
2923: <itemizedlist>
2924: <listitem><para><literal>start//attribute</literal></para></listitem>
2925: <listitem><para><literal>start//data</literal></para></listitem>
2926: <listitem><para><literal>start//value</literal></para></listitem>
2927: <listitem><para><literal>start//text</literal></para></listitem>
2928: <listitem><para><literal>start//list</literal></para></listitem>
2929: <listitem><para><literal>start//group</literal></para></listitem>
2930: <listitem><para><literal>start//interleave</literal></para></listitem>
2931: <listitem><para><literal>start//oneOrMore</literal></para></listitem>
2932: <listitem><para><literal>start//empty</literal></para></listitem>
2933: </itemizedlist>
2934: </section>
2935:
2936: </section>
2937:
2938: <section id="string-sequences">
2939: <title>String sequences</title>
2940:
2941: <para>RELAX NG does not allow a pattern such as:</para>
2942:
2943: <programlisting><![CDATA[<element name="foo">
2944: <group>
2945: <data type="int"/>
2946: <element name="bar">
2947: <empty/>
2948: </element>
2949: </group>
2950: </element>]]></programlisting>
2951:
2952: <para>Nor does it allow a pattern such as:</para>
2953:
2954: <programlisting><![CDATA[<element name="foo">
2955: <group>
2956: <data type="int"/>
2957: <text/>
2958: </group>
2959: </element>]]></programlisting>
2960:
2961: <para>More generally, if the pattern for the content of an element or
2962: attribute contains</para>
2963:
2964: <itemizedlist>
2965:
2966: <listitem><para>a pattern that can match a child
2967: (that is, an <literal>element</literal>, <literal>data</literal>,
2968: <literal>value</literal>, <literal>list</literal> or
2969: <literal>text</literal> pattern), and</para></listitem>
2970:
2971: <listitem><para>a pattern that matches a single string (that is, a
2972: <literal>data</literal>, <literal>value</literal> or
2973: <literal>list</literal> pattern),</para></listitem>
2974:
2975: </itemizedlist>
2976:
2977: <para>then the two patterns must be alternatives to each other.</para>
2978:
2979: <para>This rule does not apply to patterns occurring within a
2980: <literal>list</literal> pattern.</para>
2981:
2982: <para>To formalize this, we use the concept of a content-type. A
2983: pattern that is allowable as the content of an element has one of
2984: three content-types: empty, complex and simple. We use the following
2985: notation.</para>
2986:
2987: <variablelist>
2988:
2989: <varlistentry>
2990: <term><p:function name="empty"/></term>
2991: <listitem><para>returns the empty content-type</para></listitem>
2992: </varlistentry>
2993:
2994: <varlistentry>
2995: <term><p:function name="complex"/></term>
2996: <listitem><para>returns the complex content-type</para></listitem>
2997: </varlistentry>
2998:
2999: <varlistentry>
3000: <term><p:function name="simple"/></term>
3001: <listitem><para>returns the simple content-type</para></listitem>
3002: </varlistentry>
3003:
3004: <varlistentry><term><p:var range="contentType"/></term>
3005: <listitem><para>ranges over content-types</para></listitem>
3006: </varlistentry>
3007:
3008: <varlistentry><term>
3009: <p:judgement name="groupable">
3010: <p:var range="contentType" sub="1"/>
3011: <p:var range="contentType" sub="2"/>
3012: </p:judgement>
3013: </term>
3014: <listitem><para>asserts that the content-types <p:var
3015: range="contentType" sub="1"/> and <p:var range="contentType" sub="2"/>
3016: are groupable</para></listitem>
3017: </varlistentry>
3018:
3019: </variablelist>
3020:
3021: <para>The empty content-type is groupable with anything. In addition,
3022: the complex content-type is groupable with the complex content-type. The
3023: following rules formalize this.</para>
3024:
3025: <p:proofSystem>
3026: <p:rule name="group empty 1">
3027: <p:judgement name="groupable">
3028: <p:function name="empty"/>
3029: <p:var range="contentType"/>
3030: </p:judgement>
3031: </p:rule>
3032: <p:rule name="group empty 2">
3033: <p:judgement name="groupable">
3034: <p:var range="contentType"/>
3035: <p:function name="empty"/>
3036: </p:judgement>
3037: </p:rule>
3038: <p:rule name="group complex">
3039: <p:judgement name="groupable">
3040: <p:function name="complex"/>
3041: <p:function name="complex"/>
3042: </p:judgement>
3043: </p:rule>
3044: </p:proofSystem>
3045:
3046: <para>Some patterns have a content-type. We use the following
3047: additional notation.</para>
3048:
3049: <variablelist>
3050:
3051: <varlistentry><term>
3052: <p:judgement name="contentType">
3053: <p:var range="pattern"/>
3054: <p:var range="contentType"/>
3055: </p:judgement>
3056: </term>
3057: <listitem><para>asserts that pattern <p:var range="pattern"/> has
3058: content-type <p:var range="contentType"/></para></listitem>
3059: </varlistentry>
3060:
3061: <varlistentry><term>
3062: <p:function name="max">
3063: <p:var range="contentType" sub="1"/>
3064: <p:var range="contentType" sub="2"/>
3065: </p:function>
3066: </term>
3067: <listitem><para>returns the maximum of <p:var range="contentType"
3068: sub="1"/> and <p:var range="contentType" sub="2"/> where the
3069: content-types in increasing order are <p:function name="empty"/>,
3070: <p:function name="complex"/>, <p:function
3071: name="simple"/></para></listitem>
3072: </varlistentry>
3073:
3074: </variablelist>
3075:
3076: <para>The following rules define when a pattern has a content-type and,
3077: if so, what it is.</para>
3078:
3079: <p:proofSystem>
3080: <p:rule name="value">
3081: <p:judgement name="contentType">
3082: <p:element name="value">
3083: <p:attribute name="datatypeLibrary">
3084: <p:var range="uri" sub="1"/>
3085: </p:attribute>
3086: <p:attribute name="type">
3087: <p:var range="ncname"/>
3088: </p:attribute>
3089: <p:attribute name="ns">
3090: <p:var range="uri" sub="2"/>
3091: </p:attribute>
3092: <p:var range="string"/>
3093: </p:element>
3094: <p:function name="simple"/>
3095: </p:judgement>
3096: </p:rule>
3097:
3098: <p:rule name="data 1">
3099: <p:judgement name="contentType">
3100: <p:element name="data">
3101: <p:attribute name="datatypeLibrary">
3102: <p:var range="uri"/>
3103: </p:attribute>
3104: <p:attribute name="type">
3105: <p:var range="ncname"/>
3106: </p:attribute>
3107: <p:var range="params"/>
3108: </p:element>
3109: <p:function name="simple"/>
3110: </p:judgement>
3111: </p:rule>
3112:
3113: <p:rule name="data 2">
3114: <p:judgement name="contentType">
3115: <p:var range="pattern"/>
3116: <p:var range="contentType"/>
3117: </p:judgement>
3118: <p:judgement name="contentType">
3119: <p:element name="data">
3120: <p:attribute name="datatypeLibrary">
3121: <p:var range="uri"/>
3122: </p:attribute>
3123: <p:attribute name="type">
3124: <p:var range="ncname"/>
3125: </p:attribute>
3126: <p:var range="params"/>
3127: <p:element name="except">
3128: <p:var range="pattern"/>
3129: </p:element>
3130: </p:element>
3131: <p:function name="simple"/>
3132: </p:judgement>
3133: </p:rule>
3134:
3135: <p:rule name="list">
3136: <p:judgement name="contentType">
3137: <p:element name="list">
3138: <p:var range="pattern"/>
3139: </p:element>
3140: <p:function name="simple"/>
3141: </p:judgement>
3142: </p:rule>
3143:
3144: <p:rule name="text">
3145: <p:judgement name="contentType">
3146: <p:element name="text"/>
3147: <p:function name="complex"/>
3148: </p:judgement>
3149: </p:rule>
3150:
3151: <p:rule name="ref">
3152: <p:judgement name="contentType">
3153: <p:element name="ref">
3154: <p:attribute name="name">
3155: <p:var range="ncname"/>
3156: </p:attribute>
3157: </p:element>
3158: <p:function name="complex"/>
3159: </p:judgement>
3160: </p:rule>
3161:
3162: <p:rule name="empty">
3163: <p:judgement name="contentType">
3164: <p:element name="empty"/>
3165: <p:function name="empty"/>
3166: </p:judgement>
3167: </p:rule>
3168:
3169: <p:rule name="attribute">
3170: <p:judgement name="contentType">
3171: <p:var range="pattern"/>
3172: <p:var range="contentType"/>
3173: </p:judgement>
3174: <p:judgement name="contentType">
3175: <p:element name="attribute">
3176: <p:var range="nameClass"/>
3177: <p:var range="pattern"/>
3178: </p:element>
3179: <p:function name="empty"/>
3180: </p:judgement>
3181: </p:rule>
3182:
3183: <p:rule name="group">
3184: <p:judgement name="contentType">
3185: <p:var range="pattern" sub="1"/>
3186: <p:var range="contentType" sub="1"/>
3187: </p:judgement>
3188: <p:judgement name="contentType">
3189: <p:var range="pattern" sub="2"/>
3190: <p:var range="contentType" sub="2"/>
3191: </p:judgement>
3192: <p:judgement name="groupable">
3193: <p:var range="contentType" sub="1"/>
3194: <p:var range="contentType" sub="2"/>
3195: </p:judgement>
3196: <p:judgement name="contentType">
3197: <p:element name="group">
3198: <p:var range="pattern" sub="1"/>
3199: <p:var range="pattern" sub="2"/>
3200: </p:element>
3201: <p:function name="max">
3202: <p:var range="contentType" sub="1"/>
3203: <p:var range="contentType" sub="2"/>
3204: </p:function>
3205: </p:judgement>
3206: </p:rule>
3207:
3208: <p:rule name="interleave">
3209: <p:judgement name="contentType">
3210: <p:var range="pattern" sub="1"/>
3211: <p:var range="contentType" sub="1"/>
3212: </p:judgement>
3213: <p:judgement name="contentType">
3214: <p:var range="pattern" sub="2"/>
3215: <p:var range="contentType" sub="2"/>
3216: </p:judgement>
3217: <p:judgement name="groupable">
3218: <p:var range="contentType" sub="1"/>
3219: <p:var range="contentType" sub="2"/>
3220: </p:judgement>
3221: <p:judgement name="contentType">
3222: <p:element name="interleave">
3223: <p:var range="pattern" sub="1"/>
3224: <p:var range="pattern" sub="2"/>
3225: </p:element>
3226: <p:function name="max">
3227: <p:var range="contentType" sub="1"/>
3228: <p:var range="contentType" sub="2"/>
3229: </p:function>
3230: </p:judgement>
3231: </p:rule>
3232:
3233: <p:rule name="oneOrMore">
3234: <p:judgement name="contentType">
3235: <p:var range="pattern"/>
3236: <p:var range="contentType"/>
3237: </p:judgement>
3238: <p:judgement name="groupable">
3239: <p:var range="contentType"/>
3240: <p:var range="contentType"/>
3241: </p:judgement>
3242: <p:judgement name="contentType">
3243: <p:element name="oneOrMore">
3244: <p:var range="pattern"/>
3245: </p:element>
3246: <p:var range="contentType"/>
3247: </p:judgement>
3248: </p:rule>
3249:
3250: <p:rule name="choice">
3251: <p:judgement name="contentType">
3252: <p:var range="pattern" sub="1"/>
3253: <p:var range="contentType" sub="1"/>
3254: </p:judgement>
3255: <p:judgement name="contentType">
3256: <p:var range="pattern" sub="2"/>
3257: <p:var range="contentType" sub="2"/>
3258: </p:judgement>
3259: <p:judgement name="contentType">
3260: <p:element name="choice">
3261: <p:var range="pattern" sub="1"/>
3262: <p:var range="pattern" sub="2"/>
3263: </p:element>
3264: <p:function name="max">
3265: <p:var range="contentType" sub="1"/>
3266: <p:var range="contentType" sub="2"/>
3267: </p:function>
3268: </p:judgement>
3269: </p:rule>
3270:
3271: </p:proofSystem>
3272:
3273: <note><para>The antecedent in the (data 2) rule above is in fact
3274: redundant because of the prohibited paths in <xref
3275: linkend="context-data-except"/>.</para></note>
3276:
3277: <para>Now we can describe the restriction. We use the following
3278: notation.</para>
3279:
3280: <variablelist>
3281:
3282: <varlistentry><term>
3283: <p:judgement name="incorrectSchema"/>
3284: </term>
3285: <listitem><para>asserts that the schema is incorrect</para></listitem>
3286: </varlistentry>
3287:
3288: </variablelist>
3289:
3290: <para>All patterns occurring as the content of an element pattern must
3291: have a content-type.</para>
3292:
3293: <p:proofSystem>
3294:
3295: <p:rule name="element">
3296: <p:judgement name="bind">
3297: <p:var range="ncname"/>
3298: <p:var range="nameClass"/>
3299: <p:var range="pattern"/>
3300: </p:judgement>
3301: <p:not>
3302: <p:judgement name="contentType">
3303: <p:var range="pattern"/>
3304: <p:var range="contentType"/>
3305: </p:judgement>
3306: </p:not>
3307: <p:judgement name="incorrectSchema"/>
3308: </p:rule>
3309:
3310: </p:proofSystem>
3311:
3312: </section>
3313:
3314: <section id="attribute-restrictions">
3315: <title>Restrictions on attributes</title>
3316:
3317: <para>Duplicate attributes are not allowed. More precisely, for a
3318: pattern <literal><group> <replaceable>p1</replaceable>
3319: <replaceable>p2</replaceable> </group></literal> or
3320: <literal><interleave> <replaceable>p1</replaceable>
3321: <replaceable>p2</replaceable> </interleave></literal>, there must
3322: not be a name that belongs to both the name class of an
3323: <literal>attribute</literal> pattern occurring in
3324: <replaceable>p1</replaceable> and the name class of an
3325: <literal>attribute</literal> pattern occurring in
3326: <replaceable>p2</replaceable>. A pattern <replaceable>p1</replaceable>
3327: is defined to <firstterm>occur in</firstterm> a pattern
3328: <replaceable>p2</replaceable> if</para>
3329:
3330: <itemizedlist>
3331:
3332: <listitem><para><replaceable>p1</replaceable> is
3333: <replaceable>p2</replaceable>, or</para></listitem>
3334:
3335: <listitem><para><replaceable>p2</replaceable> is a
3336: <literal>choice</literal>, <literal>interleave</literal>,
3337: <literal>group</literal> or <literal>oneOrMore</literal> element and
3338: <replaceable>p1</replaceable> occurs in one or more children of
3339: <replaceable>p2</replaceable>.</para></listitem>
3340:
3341: </itemizedlist>
3342:
3343: <para>Attributes using infinite name classes must be repeated. More
3344: precisely, an <literal>attribute</literal> element that has an
3345: <literal>anyName</literal> or <literal>nsName</literal> descendant
3346: element must have a <literal>oneOrMore</literal> ancestor
3347: element.</para>
3348:
3349: <note><para>This restriction is necessary for closure under
3350: negation.</para></note>
3351:
3352: </section>
3353:
3354: <section id="interleave-restrictions">
3355: <title>Restrictions on <literal>interleave</literal></title>
3356:
3357: <para>For a pattern <literal><interleave>
3358: <replaceable>p1</replaceable> <replaceable>p2</replaceable>
3359: </interleave></literal>,</para>
3360:
3361: <itemizedlist>
3362:
3363: <listitem><para>there must not be a name that belongs to both the name
3364: class of an <literal>element</literal> pattern referenced by a
3365: <literal>ref</literal> pattern occurring in
3366: <replaceable>p1</replaceable> and the name class of an
3367: <literal>element</literal> pattern referenced by a
3368: <literal>ref</literal> pattern occurring in
3369: <replaceable>p2</replaceable>, and</para></listitem>
3370:
3371: <listitem><para>a <literal>text</literal> pattern must not occur in
3372: both <replaceable>p1</replaceable> and
3373: <replaceable>p2</replaceable>.</para></listitem>
3374:
3375: </itemizedlist>
3376:
3377: <para><xref linkend="attribute-restrictions"/> defines when one
3378: pattern is considered to occur in another pattern.</para>
3379:
3380: </section>
3381:
3382: </section>
3383:
3384: <section id="conformance">
3385: <title>Conformance</title>
3386:
3387: <para>A conforming RELAX NG validator must be able to determine for
3388: any XML document whether it is a correct RELAX NG schema. A
3389: conforming RELAX NG validator must be able to determine for any XML
3390: document and for any correct RELAX NG schema whether the document is
3391: valid with respect to the schema.</para>
3392:
3393: <para>However, the requirements in the preceding paragraph do not
3394: apply if the schema uses a datatype library that the validator does
3395: not support. A conforming RELAX NG validator is only required to
3396: support the built-in datatype library described in <xref
3397: linkend="built-in-datatype"/>. A validator that claims conformance to
3398: RELAX NG should document which datatype libraries it supports. The
3399: requirements in the preceding paragraph also do not apply if the
3400: schema includes <literal>externalRef</literal> or
3401: <literal>include</literal> elements and the validator is unable to
3402: retrieve the resource identified by the URI or is unable to construct
3403: an element from the retrieved resource. A validator that claims
3404: conformance to RELAX NG should document its capabilities for handling
3405: URI references.</para>
3406:
3407: </section>
3408:
3409: <appendix>
3410: <title>RELAX NG schema for RELAX NG</title>
3411:
3412: <rngref src="relaxng.rng"/>
3413:
3414: </appendix>
3415:
3416: <appendix>
3417: <title>Changes since version 0.9</title>
3418:
3419: <para>The changes in this version relative to version 0.9
3420: are as follows:</para>
3421:
3422: <itemizedlist>
3423:
3424: <listitem><para>in the namespace URI, <literal>0.9</literal> has been
3425: changed to <literal>1.0</literal></para></listitem>
3426:
3427: <listitem><para><literal>data/except//empty</literal> has been added
3428: as a prohibited path (see <xref
3429: linkend="context-data-except"/>)</para></listitem>
3430:
3431: <listitem><para><literal>start//empty</literal> has been added
3432: as a prohibited path (see <xref
3433: linkend="context-start"/>)</para></listitem>
3434:
3435: <listitem><para><xref linkend="number-child-elements"/> now specifies how a
3436: <literal>list</literal> element with more than one child element is
3437: transformed</para></listitem>
3438:
3439: <listitem><para><xref linkend="notAllowed"/> now specifies how a
3440: <literal>notAllowed</literal> element occurring in an
3441: <literal>except</literal> element is transformed</para></listitem>
3442:
3443: <listitem><para>although a relative URI is not allowed as the value of
3444: the <literal>ns</literal> and <literal>datatypeLibrary</literal>
3445: attributes, an empty string is allowed (see <xref
3446: linkend="full-syntax"/>)</para></listitem>
3447:
3448: <listitem><para>the removal of unreachable definitions in <xref
3449: linkend="define-ref"/> is now correctly specified</para></listitem>
3450:
3451: <listitem><para><xref linkend="notAllowed"/> now specifies that
3452: <literal>define</literal> elements that are no longer reachable are
3453: removed</para></listitem>
3454:
3455: <listitem><para><xref linkend="constraints"/> has been added; the
3456: restrictions on the contents of <literal>except</literal> in name
3457: classes that are now specified in the newly added section were
3458: previously specified in a subsection of <xref
3459: linkend="contextual-restriction"/>, which has been
3460: removed</para></listitem>
3461:
3462: <listitem><para>the treatment of element and attribute values that
3463: consist only of whitespace has been refined (see <xref
3464: linkend="element-pattern"/> and <xref
3465: linkend="data-pattern"/>)</para></listitem>
3466:
3467: <listitem><para>attributes with infinite name classes are now required
3468: to be repeated (see <xref
3469: linkend="attribute-restrictions"/>)</para></listitem>
3470:
3471: <listitem><para>restrictions have been imposed on
3472: <literal>interleave</literal> (see <xref
3473: linkend="interleave-restrictions"/>); <literal>list//interleave</literal>
3474: has been added as a prohibited path (see <xref
3475: linkend="list-restrictions"/>)</para></listitem>
3476:
3477: <listitem><para>some of the prohibited paths in <xref
3478: linkend="contextual-restriction"/> have been corrected to use
3479: <literal>ref</literal> rather than
3480: <literal>element</literal></para></listitem>
3481:
3482: <listitem><para>an error in the inference rule (text 1) in <xref
3483: linkend="text-pattern"/> has been corrected</para></listitem>
3484:
3485: <listitem><para>the value of the <literal>ns</literal> attribute is
3486: now unconstrained (see <xref
3487: linkend="full-syntax"/>)</para></listitem>
3488:
3489: </itemizedlist>
3490:
3491: </appendix>
3492:
3493: <appendix>
3494: <title>RELAX NG TC (Non-Normative)</title>
3495:
3496: <para>This specification was prepared and approved for publication by
3497: the RELAX NG TC. The current members of the TC are:</para>
3498:
3499: <itemizedlist>
3500: <listitem><para>Fabio Arciniegas</para></listitem>
3501: <listitem><para>James Clark</para></listitem>
3502: <listitem><para>Mike Fitzgerald</para></listitem>
3503: <listitem><para>KAWAGUCHI Kohsuke</para></listitem>
3504: <listitem><para>Josh Lubell</para></listitem>
3505: <listitem><para>MURATA Makoto</para></listitem>
3506: <listitem><para>Norman Walsh</para></listitem>
3507: <listitem><para>David Webber</para></listitem>
3508: </itemizedlist>
3509:
3510: </appendix>
3511:
3512: <bibliography><title>References</title>
3513:
3514: <bibliodiv><title>Normative</title>
3515:
3516: <bibliomixed id="xml-rec"><abbrev>XML 1.0</abbrev>Tim Bray,
3517: Jean Paoli, and
3518: C. M. Sperberg-McQueen, Eve Maler, editors.
3519: <citetitle><ulink url="http://www.w3.org/TR/REC-xml">Extensible Markup
3520: Language (XML) 1.0 Second Edition</ulink></citetitle>.
3521: W3C (World Wide Web Consortium), 2000.</bibliomixed>
3522:
3523: <bibliomixed id="xml-names"><abbrev>XML Namespaces</abbrev>Tim Bray,
3524: Dave Hollander,
3525: and Andrew Layman, editors.
3526: <citetitle><ulink url="http://www.w3.org/TR/REC-xml-names/">Namespaces in
3527: XML</ulink></citetitle>.
3528: W3C (World Wide Web Consortium), 1999.</bibliomixed>
3529:
3530: <bibliomixed id="xlink"><abbrev>XLink</abbrev>Steve DeRose, Eve Maler
3531: and David Orchard, editors.
3532: <citetitle><ulink url="http://www.w3.org/TR/xlink/">XML Linking
3533: Language (XLink) Version 1.0</ulink></citetitle>.
3534: W3C (World Wide Web Consortium), 2001.</bibliomixed>
3535:
3536: <bibliomixed id="infoset"><abbrev>XML Infoset</abbrev>John Cowan, Richard Tobin,
3537: editors.
3538: <citetitle><ulink url="http://www.w3.org/TR/xml-infoset/">XML
3539: Information Set</ulink></citetitle>.
3540: W3C (World Wide Web Consortium), 2001.</bibliomixed>
3541:
3542: <bibliomixed id="rfc2396"><abbrev>RFC 2396</abbrev>T. Berners-Lee, R. Fielding, L. Masinter.
3543: <citetitle><ulink url="http://www.ietf.org/rfc/rfc2396.txt" >RFC 2396:
3544: Uniform Resource Identifiers (URI): Generic
3545: Syntax</ulink></citetitle>.
3546: IETF (Internet Engineering Task Force). 1998.</bibliomixed>
3547:
3548: <bibliomixed id="rfc2732"><abbrev>RFC 2732</abbrev>R. Hinden, B. Carpenter, L. Masinter.
3549: <citetitle><ulink url="http://www.ietf.org/rfc/rfc2732.txt">RFC 2732: Format for Literal IPv6 Addresses in URL's</ulink></citetitle>.
3550: IETF (Internet Engineering Task Force), 1999.</bibliomixed>
3551:
3552: <bibliomixed id="rfc3023"><abbrev>RFC 3023</abbrev> M. Murata,
3553: S. St.Laurent, D. Kohn. <citetitle><ulink
3554: url="http://www.ietf.org/rfc/rfc3023.txt">RFC 3023: XML Media
3555: Types</ulink></citetitle>. IETF (Internet Engineering Task Force),
3556: 2001.</bibliomixed>
3557:
3558: </bibliodiv>
3559:
3560: <bibliodiv><title>Non-Normative</title>
3561:
3562: <bibliomixed id="xmlschema-2"><abbrev>W3C XML Schema Datatypes</abbrev>Paul V. Biron, Ashok Malhotra, editors.
3563: <citetitle><ulink url="http://www.w3.org/TR/xmlschema-2/">XML Schema Part 2: Datatypes</ulink></citetitle>.
3564: W3C (World Wide Web Consortium), 2001.</bibliomixed>
3565:
3566: <bibliomixed id="trex"><abbrev>TREX</abbrev>James Clark.
3567: <citetitle><ulink url="http://www.thaiopensource.com/trex/">TREX - Tree Regular Expressions for XML</ulink></citetitle>.
3568: Thai Open Source Software Center, 2001.</bibliomixed>
3569:
3570: <bibliomixed id="relax"><abbrev>RELAX</abbrev>MURATA Makoto.
3571: <citetitle><ulink url="http://www.xml.gr.jp/relax/">RELAX (Regular
3572: Language description for XML)</ulink></citetitle>. INSTAC
3573: (Information Technology Research and Standardization Center), 2001.</bibliomixed>
3574:
3575: <bibliomixed id="xsfd"><abbrev>XML Schema Formal</abbrev>Allen Brown,
3576: Matthew Fuchs, Jonathan Robie, Philip Wadler, editors.
3577: <citetitle><ulink url="http://www.w3.org/TR/xmlschema-formal/">XML Schema: Formal Description</ulink></citetitle>.
3578: W3C (World Wide Web Consortium), 2001.</bibliomixed>
3579:
3580: <bibliomixed id="tutorial"><abbrev>Tutorial</abbrev>James Clark,
3581: Makoto MURATA, editors. <citetitle><ulink
3582: url="http://www.oasis-open.org/committees/relax-ng/tutorial.html">RELAX
3583: NG Tutorial</ulink></citetitle>. OASIS, 2001.</bibliomixed>
3584:
3585: </bibliodiv>
3586:
3587: </bibliography>
3588:
3589: </article>
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to spec_0.xml CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / test / relaxng