libxml2/test/relaxng/spec_0.xml

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