xml/xmlcc/xmlcc-work.en.html

<!DOCTYPE html>
<html lang="en" class="formal-specification status-work-in-progress">
<head>
<title>manakai's XML Conformance Checking</title>
<link rel="stylesheet" href="http://suika.fam.cx/www/style/html/spec">
<link rel="license" href="http://suika.fam.cx/c/gnu/fdl">
<style>
  a[id]::before {
    content: "[" attr(id) "]";
    color: gray;
    font-size: 70%;
    font-family: Courier New, monospace;
    vertical-align: 60%;
  }
</style>
</head>
<body class="has-abstract">

<div class="header">
<h1>manakai's <abbr>XML</abbr> Conformance Checking</h1>
<h2>Working Draft <time datetime=2008-10-17>17 October 2008</time></h2>

<dl class="versions-uri">
<dt>This Version</dt>
  <dd><code class="URI">&lt;<a href="http://suika.fam.cx/www/markup/xml/xmlcc/xmlcc-work"
      >http://suika.fam.cx/www/markup/xml/xmlcc/xmlcc-work</a>&gt;</code></dd>
<dt>Latest Version</dt>
  <dd><code class="URI">&lt;<a href="http://suika.fam.cx/www/markup/xml/xmlcc/xmlcc"
      >http://suika.fam.cx/www/markup/xml/xmlcc/xmlcc</a>&gt;</code></dd>
<dt>Latest Working Draft</dt>
  <dd><code class="URI">&lt;<a href="http://suika.fam.cx/www/markup/xml/xmlcc/xmlcc-work"
      >http://suika.fam.cx/www/markup/xml/xmlcc/xmlcc-work</a>&gt;</code></dd>
<!-- <dt>Previous Version</dt> -->
<dt>Version History</dt>
  <dd><code class=URI>&lt;<a href="http://suika.fam.cx/gate/cvs/markup/xml/xmlcc/xmlcc-work.en.html">http://suika.fam.cx/gate/cvs/markup/xml/xmlcc/xmlcc-work.en.html</a>&gt;</code></dd>
</dl>
<dl class="authors" id="author">
<dt>Author</dt>
  <dd><a href="http://suika.fam.cx/~wakaba/who?" rel="author"
      lang=ja>Wakaba</a>
  <code class="mail">&lt;<a href="mailto:w@suika.fam.cx" rel="author"
      >w@suika.fam.cx</a>&gt;</code></dd>
</dl>

<p class="copyright" lang="en">&#xA9; <time>2007</time>$B!>(B<time>2008</time> <a
    href="http://suika.fam.cx/~wakaba/who?" rel="author">Wakaba</a>.
Permission is granted to copy, distribute and/or modify this document
under the terms of the <a rel="license"
href="http://www.gnu.org/copyleft/fdl.html">GNU Free Documentation License</a>,
Version 1.2
or any later version published by the <a
href="http://www.fsf.org/">Free Software Foundation</a>;
with no Invariant Sections, no Front$B!>(BCover Texts, and no Back$B!>(BCover
Texts.  A copy of the license is
available at <code class="URI">&lt;<a
    href="http://www.gnu.org/copyleft/fdl.html"
    rel="license">http://www.gnu.org/copyleft/fdl.html</a>&gt;</code>.</p>
</div>

<div id="abstract" class="section">
<h2>Abstract</h2>

<div class="ed issue">...</div>

</div>

<div id="status" class="section">
<h2>Status of This Document</h2>

<p class=section-info><em>This section describes the status of this document
at the time of its publication.  Other documents
might supersede this document.</em></p>

<p>This document is a working draft, produced as part of the 
<a href="http://suika.fam.cx/www/markup/html/whatpm/readme">Whatpm</a>
subproject of the 
<a href="http://suika.fam.cx/www/manakai-core/doc/web/">manakai</a> 
project.  It might be updated, replaced, or obsoleted by
other documents at any time.  It is inappropriate to
cite this document as other than <q>work in progress</q>.</p>

<p>The scope of this specification is explicitly limited to the <a
href="http://suika.fam.cx/www/markup/html/whatpm/readme">Whatpm</a>
implementation.  It is <em>not</em> the purpose of this specification
to define a general guideline to parse or to check XML documents.
This specification does <em>not</em> try to define a new version of
XML at all.

<p>This version of the specification supports the fourth edition of
XML 1.0 and the second edition of XML 1.1.  The fifth edition of XML
1.0 might be supported in a later version.  XML namespaces
specifications is expected to be supported in a later version of this
specification.

<p>Comments on this document are welcome and
may be sent to the <a href="#author">author</a>.</p>

<p>Translations of thie document might be available.
The English version of the document is the only
normative version.</p>
</div>

<div id="introduction" class="section">
<h2>Introduction</h2>

<p class=section-info>This section is <em>non$B!>(Bnormative</em>.</p>

<p>This specification defines how the parsing and the conformance
checking of XML documents should be implemented in the <a
href="http://suika.fam.cx/www/markup/html/whatpm/readme">Whatpm</a>
XML parser and conformance checker.

<p>It is <em>not</em> the purpose of this specification to define,
e.g., how to parse XML documents in general; its scope is explicitly
limited to the <a
href="http://suika.fam.cx/www/markup/html/whatpm/readme">Whatpm</a>
implementation.

<div class="issue ed">...

<p>Much of invalid (well-formed or not) XML document parsing and XML document
/ XML DOM conformance is left undefined so that this document provides a
guideline for conformance checkers.
</div>


</div>

<div class="section" id="terminology">
<h2>Terminology</h2>

<p>The key words <q><em class="rfc2119">MUST</em></q>,
<q><em class="rfc2119">MUST NOT</em></q>,
<q><em class="rfc2119">SHOULD</em></q>,
<q><em class="rfc2119">SHOULD NOT</em></q>, and
<q><em class=rfc2119>MAY</em></q> in this
document are to be interpreted as described in 
<a href="urn:ietf:rfc:2119"><abbr title="Request for Comments">RFC</abbr> 
2119</a>
<cite class="bibref normative">[<a href="#ref-KEYWORDS">KEYWORDS</a>]</cite>.</p>

<!-- Strictly speaking the paragraph below is not part of terminology. -->
<p>All examples and notes in this specification are non$B!>(Bnormative,
as are all sections explicitly marked non$B!>(Bnormative.  Everything
else in this specification is normative.</p>

<p><span class=ed>Algorithm is normative but non-normative</span>.
In addition, the order in which <a href="#errors">errors</a> are
raised is undefined.</p>

<p>This document sometimes cites parts of <abbr>XML</abbr> 1.0 specification
by hyperlinks.  When the document being processed is an <abbr>XML</abbr> 1.1
document, however, corresponding parts of the <abbr>XML</abbr> 1.1 
specification should be consulted instead.</p>
</div>

<div class=section id=processing-model>
<h2>Processing Model</h2>

<p>Conceptually, validation of an XML document is split into two
stages for the purpose of this specification: the <dfn
id=xml-document-parsing>XML document parsing</dfn> stage and the <dfn
id=dom-xml-conformance-checking>DOM XML conformance checking</dfn>
stage.

<p>The input to the XML document parsing stage is a byte sequence
representing the parsed XML document (and any additional metadata),
and the output are a DOM tree representing the XML document and zero
or more <a href="#error">errors</a>.  The processor that implements
this stage is called <dfn id=parser>parser</dfn>.  Requirements for a
parser are defined in the section of <a href="#parsing-xml">Parsing an
XML Document</a>.

<p>The input to the DOM XML conformance chcking stage is a DOM tree,
and the output are zero or more <a href="#error">errors</a>.  The
processor that implements this stage is called <dfn
id=conformance-checker>conformance checker</dfn>.  Requirements for a
conformance checker are defined in the section of <a
href="#checking-dom">Checking an XML DOM Tree</a>.


<div class=section id=error-categories>
<h3>Error Classification</h3>

<p class=ed>An <dfn id=error>error</dfn> is ...

<p class=ed>If a <code>Document</code> node has no 
xml-well-formedness-error, entity-error, and unknown-error,
then it is well-formed.  If a well-formed <code>Document</code>
node has no xml-validity-error, it is valid.</p>

<div class="note memo">
<p>A well$B!>(Bformed <code>Document</code> can be safely serialized
into a well$B!>(Bformed XML document.  A valid <code>Document</code>
can be easily serialized into a valid XML document.</p>
</div>

<p class=ed>To be a conforming <a href="http://www.w3.org/TR/2006/REC-xml-20060816/#dt-validating">validating XML processor</a>,
...</p>

<p>Errors are classified into these 
<dfn id=error-category title="error category">error categories</dfn>:</p>

<dl id=errors>
<dt><dfn id=entity-error><code>entity-error</code></dfn></dt>
  <dd>
    <p class=ed>@@</p>
    <div class="note memo">
      <p>This <span class=ed>algorithm</span> does not support
      <abbr>DOM</abbr> tree with one or more <code>EntityReference</code>
      nodes.  It is expected that any entity references are expanded
      at the parse time and any unexpandable entity references
      make parse time errors raised so that never result in
      <abbr>DOM</abbr> tree with <code>EntityReference</code> nodes.</p>
    </div>
  </dd>
<dt><dfn id=round-trip-error><code>round-trip-error</code></dfn></dt>
  <dd class=ed>@@</dd>
<dt><dfn id=round-trip-warning><code>round-trip-warning</code></dfn></dt>
  <dd>
    <p>A <a href="#round-trip-warning"><code>round-trip-warning</code></a>
    will be raised when a construct, which might not be restored to the same
    construct when it is serialized and then re-parsed by a conforming
    processor, is encountered.</p>
    <div class="example memo">
      <p>For a <code>Comment</code> node a
      <a href="#round-trip-warning"><code>round-trip-warning</code></a> will
      be raised, since <abbr>XML</abbr> processors are not required to
      report texts of comments for applications.</p>
    </div>
  </dd>
<dt class=ed><dfn id=unknown-error><code>unknown-error</code></dfn>?</dt>
  <dd class=ed>@@</dd>
<dt><dfn id=xml-misc-error><code>xml-misc-error</code></dt>
  <dd>An <abbr>XML</abbr> <i>error</i> (<abbr>XML</abbr> 1.0
  <cite class="bibref normative">[<a href="#ref-XML10">XML10</a>]</cite> 
  <a href="http://www.w3.org/TR/2006/REC-xml-20060816/#dt-error">error</a> /
  <abbr>XML</abbr> 1.1
  <cite class="bibref normative">[<a href="#ref-XML11">XML11</a>]</cite>
  <a href="@@/#dt-error">error</a>)
  that is not classified to any other <a href="#error-category">error
  category</a>.</dd>
<dt><dfn id=xml-misc-fatal-error><code>xml-misc-fatal-error</code></dt>
  <dd>An <abbr>XML</abbr> <i>fatal error</i> (<abbr>XML</abbr> 1.0
  <cite class="bibref normative">[<a href="#ref-XML10">XML10</a>]</cite> 
  <a href="http://www.w3.org/TR/2006/REC-xml-20060816/#dt-fatal">fatal
  error</a> / <abbr>XML</abbr> 1.1
  <cite class="bibref normative">[<a href="#ref-XML11">XML11</a>]</cite>
  <a href="@@/#dt-fatal">fatal error</a>)
  that is not classified to any other <a href="#error-category">error
  category</a>. <span class=ed>@@ What errors fall into this category?</span></dd>
<dt><dfn id=xml-misc-recommendation><code>xml-misc-recommendation</code></dfn></dt>
  <dd>
    <p>An
    <a href="#xml-misc-recommendation"><code>xml-misc-recommendation</code></a>
    will be raised if a <em class=rfc2119>SHOULD</em>$B!>(Blevel requirement
    in <abbr>XML</abbr> specification is not met.</p>
  </dd>
<dt><dfn id=xml-validity-error><code>xml-validity-error</code></dfn></dt>
  <dd>A violation of validity constraint in XML document.</dd>
<dt><dfn id=xml-well-formedness-error><code>xml-well-formedness-error</code></dfn></dt>
  <dd><p>If an <code>xml-well-formedness-error</code> is raised,
  it would not be possible to generate an XML serialization that
  would match to the appropriate production rule and that would not 
  violate to any well$B!>(Bformedness constraint in XML
  specification <cite class="bibref normative">[<a href="#ref-XML10">XML10</a>,
  <a href="#ref-XML11">XML11</a>]</cite>.</p></dd>
<dt><dfn id=misc-info><code>misc-info</code></dfn>
  <dd><p>A <code>misc-info</code> is raised when some status information
  on parsing or checking process that are considered useful for debugging
  and so on is available.  It by no means implies the non-conformance of
  the document.
</dl>

<div class=ed><p>@@ TODO: #dt-atuseroption at user option
(MAY or MUST), #dt-compat for compatibility,
#dt-interop for interoperability</p>

<p>TODO: XML 1.1, XML Namespace 1.0/1.1, xml:base, xml:id

<p>TODO: XML "error"/"fatal error" is not always non-conforming (only
when MUST or SHOULD).
</div>

</div>

</div>

<div class=section id=parsing-xml>
<h2>Parsing an <abbr>XML</abbr> Document</h2>

<p>When a byte stream that represents an XML document is given to a
parser, it <em class=rfc2119>MUST</em> create a DOM tree according to
relevant specifications <span class=ed>[XML10, XML11, XMLNAMES10,
XMLNAMES11, DOM3CORE, WEBDOMCORE, DOMDTDEF, MANAKAIDOMEXT]</span>.

<p>The parser <em class=rfc2119>MAY</em> continue the parsing of the
document even after a fatal error (as defined by the relavant
specifications) is encountered.  How the parsing ought to be continued
is not defined by this specification.

<!--
  <div class="note memo informative">
  <p>It is expected that the XML5 specification <span class=ed>@@ ref</span>
  will define how the parser has to convert any string into DOM tree
  completely.
  </div>
-->

<p class=ed>A future version of this specification might define the
entire parser in terms of input stream preprocessor, tokenizer, and
tree constructor.

<p>In addition, the following requirements are applied to the parser:

<dl class=switch>
<dt>For each external entity (including the document entity and the external
subset entity, if any)
  <dd>If there is a byte sequence that are not legal in the encoding in use,
  then the parser <em class=rfc2119>MUST</em> raise an
  <a href="#xml-misc-error" id=xme-illegal-bytes><code>xml-misc-error</code></a>.
  <!--
     <q>It is a fatal error when an XML processor encounters an entity with an
     encoding that it is unable to process. It is a fatal error if an XML
     entity is determined (via default, encoding declaration, or higher-level
     protocol) to be in a certain encoding but contains byte sequences that are
     not legal in that encoding.</q>
  -->

  <dd>If it is the document entity or a general entity, then:
    <ul>
    <li>If the input byte sequence for the entity begins with the
    <abbr title="BYTE ORDER MARK" class=charname>BOM</abbr>, then the parser
    <em class=rfc2119>MUST</em> set the <span class=ed>BOM flag</span> of
    the node corresponding to the entity (the <code>Document</code> node
    for the document entity or an <code>Entity</code> node for a general
    entity) to <code>true</code>.
    <!--
      <q>Entities encoded in UTF-16 MUST and entities encoded in UTF-8 MAY
      begin with the Byte Order Mark</q>
    -->
    <span class=ed>@@ flag must be checked later</span>
    <!-- <?xml encoding=""?> must be reflected to xmlEncoding; this should be
    enforced by DOM Core spec. -->
    </ul>
  <dd>If it is a parameter entity or the external subset entity, then:
    <ul>
    <li>If the character encoding of the entity is <code>UTF-16</code> but
    the input byte stream for the entity does not begin with the
    <abbr title="BYTE ORDER MARK" class=charname>BOM</abbr>, then the parser
    <em class=rfc2119>MUST</em> raise an
    <a href="#xml-misc-error" id=xme-pe-bom><code>xml-misc-error</code></a>.
    <li class=ed>@@ encoding="" preferred name?
<!--
"In an encoding declaration, the values "UTF-8", "UTF-16", "ISO-10646-UCS-2", and "ISO-10646-UCS-4" SHOULD be used for the various encodings and transformations of Unicode / ISO/IEC 10646, the values "ISO-8859-1", "ISO-8859-2", ... "ISO-8859-n" (where n is the part number) SHOULD be used for the parts of ISO 8859, and the values "ISO-2022-JP", "Shift_JIS", and "EUC-JP" SHOULD be used for the various encoded forms of JIS X-0208-1997. It is RECOMMENDED that character encodings registered (as charsets) with the Internet Assigned Numbers Authority [IANA-CHARSETS], other than those just listed, be referred to using their registered names; other encodings SHOULD use names starting with an "x-" prefix."

In addition, this should be checked later for Document and Entity nodes.
-->
    </ul>

<dt>For the document
  <dd>If the <abbr>XML</abbr> document does not begin with an
  <abbr>XML</abbr> declaration, then the parser <em class=rfc2119>MUST</em>
  raise an
  <a href="#xml-misc-recommentation" id=xmr-xml-decl><code>xml-misc-recommendation</code></a>.
  <dd>If the document does not contain the document type declaration, or
  if it does but the document type definition does not contain entity 
  declaration for any of <code>amp</code>, <code>lt</code>, <code>gt</code>,
  <code>apos</code>, or <code>quot</code>, then the parser
  <em class=rfc2119>MUST</em> raise
  <a href="#xml-misc-recommentation" id=xmr-predefined-decl><code>xml-misc-recommendation</code></a>(s).
  <!--
    <q>For interoperability, valid documents SHOULD declare the entities
    amp, lt, gt, apos, quot, in the form specified in 4.6 Predefined
    Entities.</q>
  -->
<dt>For the document type declaration
  <dd class=ed>@@ read external entity
  <dd>The <code>entities</code> attribute of the <code>DocumentType</code>
  node <em class=rfc2119>MUST</em> contain a <code>NamedNodeMap</code> object
  whose first five items are as follows:
    <ol start=0>
    <li>An <code>Entity</code> node whose <code>nodeName</code> attribute
    is <code>amp</code>.  It contains a <code>Text</code> node whose
    <code>data</code> attribute is set to <code>&amp;</code>.
    <li>An <code>Entity</code> node whose <code>nodeName</code> attribute
    is <code>lt</code>.  It contains a <code>Text</code> node whose
    <code>data</code> attribute is set to <code>&lt;</code>.
    <li>An <code>Entity</code> node whose <code>nodeName</code> attribute
    is <code>gt</code>.  It contains a <code>Text</code> node whose
    <code>data</code> attribute is set to <code>></code>.
    <li>An <code>Entity</code> node whose <code>nodeName</code> attribute
    is <code>quot</code>.  It contains a <code>Text</code> node whose
    <code>data</code> attribute is set to <code>"</code>.
    <li>An <code>Entity</code> node whose <code>nodeName</code> attribute
    is <code>apos</code>.  It contains a <code>Text</code> node whose
    <code>data</code> attribute is set to <code>'</code>.
    </ol>
<dt>For each internal general entity declaration being processed by the parser
  <dd>If the 
  <a href="http://www.w3.org/TR/2006/REC-xml-20060816/#NT-EntityValue"><code>EntityValue</code></a>
  part of the general entity declaration contains a bare <code>U+003C</code>
  <code>LESS-THAN SIGN</code> (<code>&lt;</code>) character, then the parser
  <em class=rfc2119>MUST</em> raise an
  <a href="#xml-misc-warning" id=xmw-entity-value-lt><code>xml-misc-warning</code></a>.<!--
"strongly advised to avoid" in a Note in Section 2.3 of [XML10], [XML11].
-->
<dt>For each element type declaration being processed by the parser
  <dd>If there is another processed element type declaration whose
  <code>Name</code> is equal to the <code>Name</code> of the element type
  declaration, then the parser <em class=rfc2119>MUST</em> raise an 
  <a href="#xml-validity-error" id=vc-edunique><code>xml-validity-error</code></a>.
<dt>For each attribute definition list declaration being processed by the
parser
  <dd>If there is another processed attribute defintion list declaration whose
  <code>Name</code> is equal to the <code>Name</code> of the attribute
  definition list declaration, then the parser <em class=rfc2119>MUST</em>
  raise an 
  <a href="#xml-misc-warning" id=xme-attlist-unique><code>xml-misc-warning</code></a>.
  <dd>For each attribute definition in the attribute definition list 
  declaration, if there is another processed attribute definition whose
  <code>Name</code> is equal to the <code>Name</code> of the attribute
  definition (whether or not in the same attribute definition list
  declaration), then the parser <em class=rfc2119>MUST</em> raise an
  <a href="#xml-misc-warning" id=xme-attrdef-unique><code>xml-misc-warning</code></a>.
  <!--
    <q>For interoperability, an XML processor <em class=rfc2119>MAY</em> at
    user option issue a warning when more than one attribute-list declaration
    is provided for a given element type, or more than one attribute definition
    is provided for a given attribute, but this is not an error.</q>
  -->
<!--
  NOTE: <!ATTLIST a xml:space (default) #IMPLIED xml:space CDATA #IMPLIED>
  will not be warned.
-->

<dt>For each entity declaration being processed by the parser
  <dd>Handle as follows:
    <ol>
    <li><p>If the entity declaration declares a general entity, the following
    is applied:
      <dl>
      <dt>If the <code>Name</code> is <code>lt</code> or <code>amp</code>
        <dd><p>If the entity declaration does not declare an internal entity,
        or if the replacement text of the entity is not the escaped form of
        <code>&lt;</code> (if <code>lt</code>) or <code>&amp;</code> (if
        <code>amp</code>), then the parser <em class=rfc2119>MUST</em> raise an
        <a href="#xml-misc-error" id=xme-double-escape><code>xml-misc-error</code></a>.

          <div class="note memo informative">
          <p>In other word, the character in the <code>EntityValue</code>
          has to be double-escaped.
          </div>
      <dt>If the <code>Name</code> is <code>gt</code>, <code>quot</code>, or
      <code>apos</code>
        <dd><p>If the entity declaration does not declare an internal entity,
        or if the replacement text of the entity is not equal to or not the
        escaped form of <code>></code> (if <code>gt</code>), <code>"</code> (if
        <code>quot</code>), or <code>'</code> (if <code>apos</code>), then the
        parser <em class=rfc2119>MUST</em> raise an
        <a href="#xml-misc-error" id=xme-single-escape><code>xml-misc-error</code></a>.

          <div class="note memo informative">
          <p>In other word, the character in the <code>EntityValue</code>
          has to be single- or double-escaped.
          </div>
      </dl>
      <!--
        <q>If the entities lt or amp are declared, they MUST be declared as internal entities whose replacement text is a character reference to the respective character (less-than sign or ampersand) being escaped; the double escaping is REQUIRED for these entities so that references to them produce a well-formed result. If the entities gt, apos, or quot are declared, they MUST be declared as internal entities whose replacement text is the single character being escaped (or a character reference to that character; the double escaping here is OPTIONAL but harmless).</q>
      -->

    <li><p>If the entity declaration has to be ignored since there has already
    been declared an entity with the same <code>Name</code> as the declaration,
    then the parser <em class=rfc2119>MUST</em> raise a
    <a href="#misc-info" id=mi-ent-unique><code>misc-info</code></a>
    and abort these steps.

    <div class="informative note memo">
    <p>Five predefined entities, i.e. <code>amp</code>, <code>lt</code>,
    <code>gt</code>, <code>quot</code>, and <code>apos</code>, are always
    declared implicitly and therefore any declaration for such an entity 
    always raises an
    <a href="#misc-info" id=mi-ent-unique><code>misc-info</code></a>.
    </div>  

    <li><p>If the entity declaration declares a parameter entity and the
    <code>Name</code> of the entity begins with the string <code>xml</code>
    (in any combination of upper- and lowercase letters), then the parser
    <em class=rfc2119>MUST</em> raise an
    <a href="#xml-misc-warning" id=xmw-reserved-pe-name><code>xml-misc-warning</code></a>.

    <li><p>If the entity declaration contains the <code>EntityValue</code>,
    then for each occurence of any references to unparsed entities in the
    <code>EntityValue</code>, the parser <em class=rfc2119>MUST</em> raise an
    <a href="#xml-misc-error" id=xme-unparsed-in-ev><code>xml-misc-error</code></a>.
    <!--
      <q>It is an error for a reference to an unparsed entity to appear in the
      EntityValue in an entity declaration.</q>
    -->
    <li><p>If the entity declaration declares a general entity, then an
    <code>Entity</code> node <em class=rfc2119>MUST</em> be created and
    appended to the <code>NamedNodeMap</code> object in the
    <code>entities</code> attribute of the <code>DocumentType</code> node.
    
    <p class=ed>Read the external entity

    <p>If the replacement text of the entity is read, then parse the 
    replacement text as if it were referenced from the content of an
    element (with no namespace bindings).  If no <span class=ed>@@ parse error</span>
    is raised by the parsing process, then the nodes generated by the
    parsing <em class=rfc2119>MUST</em> be appended to the <code>Entity</code>
    node.  The parse error <em class=rfc2119>MUST NOT</em> be propagated to
    the entire parsing process.  Other kinds of errors
    <em class=rfc2119>MUST</em> be propagated.  The first parse error
    <em class=rfc2119>MUST</em> abort the internal parsing process.
    <span class=ed>@@ better wording</span>

    <p class=ed>@@ prop
     
    <p>Then, the <code>Entity</code> node and its descendant 
    <em class=rfc2119>MUST</em> be marked as read-only.
  </ol>

<dt>For each notation declaration being processed by the parser
  <dd>If there is another processed notation declaration whose
  <code>Name</code> is equal to the <code>Name</code> of the notation
  declaration, then the parser <em class=rfc2119>MUST</em> raise an 
  <a href="#xml-validity-error" id=vc-uniquenotationname><code>xml-validity-error</code></a>.
  <!-- <a href="http://www.w3.org/TR/2006/REC-xml-20060816/#UniqueNotationName">Validity constraint: Unique Notation Name</a> -->

<dt>For each empty-element tag
  <dd>If the <code>Name</code> of the tag is not declared by a processed
  element type declaration as <code>EMPTY</code> content, then the parser
  <em class=rfc2119>MUST</em> raise an
  <a href="#xml-misc-recommentation" id=xmr-emptyelemtag-not-empty><code>xml-misc-recommendation</code></a>.
<dt>For each start-tag
  <dd>If the <code>Name</code> of the tag is declared by a processed element
  type declaration as <code>EMPTY</code> content, then the parser
  <em class=rfc2119>MUST</em> raise an
  <a href="#xml-misc-recommentation" id=xmr-empty-not-emptyelemtag><code>xml-misc-recommendation</code></a>.
<dt>For each attribute
  <dd><p>The parser <em class=rfc2119>MUST</em> set the normalized value of 
  the attribute to the <code>value</code> attribute of the <code>Attr</code>
  node created for the attribute.

    <div class="note memo informative">
    <p>That is, any entity reference has to be expanded.  Unexpanded entity
    references in attribute values are discarded.
    </div>
<dt>For each <code>xml:space</code> attribute
  <dd>The parser <em class=rfc2119>MUST</em> set the normalized value of
  the <code>xml:space</code> attribute to the <code>value</code> attribute
  of the <code>Attr</code> node created for the attribute even if the
  normalized value is different from <code>default</code> or
  <code>preserve</code>.
  <!-- In XML 1.0/1.1 specification, the attribute specification MAY be
  ignored. -->

<dt>For each parameter entity reference
  <dd><p>Process as follows:
    <ol>
    <li>If the declaration for the entity is <em>not</em> processed,
    then:
      <dl class=switch>
      <dt>If the document contains no external entity or if the document
      contains the <code>standalone</code> pseudo-attribute set to
      <code>yes</code><!-- or the document contains no DTD -->
        <dd>The parser <em class=rfc2119>MUST</em> raise an
        <a href="#xml-well-formedness-error" id=wf-entdeclared-pe><code>xml-well-formedness-error</code></a>.
      <dt>Otherwise
        <dd>The parser <em class=rfc2119>MUST</em> raise an
        <a href="#xml-validity-error" id=vc-entdeclared-pe><code>xml-validity-error</code></a>.
      </dl>
    <li>If the declaration for the entity <em>is</em> processed but the
    referenced entity cannot be retrieved, then the parser
    <em class=rfc2119>MUST</em> raise an
    <span class=ed>@@ ??-error</span>.
    </ol>

    <p>In any of two cases above, process as follows:
    <ul>
    <li>If the parameter entity reference is contained in a declaration, then
    the declaration <em class=rfc2119>MUST</em> be ignored <em>except</em> that
    any error before the parameter entity <em class=rfc2119>MUST</em> be
    raised as usual.
    <li>If the parameter entity reference is contained in the status portion of
    a conditional section, then the conditional section
    <em class=rfc2119>MUST</em> be processed as if it were an
    <code>IGNORE</code>d section.
    <li>The parser <em class=rfc2119>MUST NOT</em> process any entity or
    attribute-list declaration after the parameter entity reference in the DTD
    <em>except</em> when the <code>standalone</code> pseudo-attribute of the
    XML declaration (if any) is set to <code>yes</code>.
    <!-- This requirement is enforced for internal DTD subset case in
    XML 1.0/1.1 specification (section 5.1) but not for any other cases. -->
    <!-- According to this definition, element type declarations, notation
    declarations, and PIs ARE processed. -->
    <li>If the parameter entity reference is the first reference to an entity
    that is not read, then the parser <em class=rfc2119>MUST</em> raise an
    <a href="#entity-error" id=ee-unread-pe><code>entity-error</code></a>.
    <li>The <code>allDeclarationsProcessed</code> <span class=ed>@@ ref</span>
    attribute of the <code>Document</code> node <em class=rfc2119>MUST</em> be
    set to <code>false</code>.
    </ul>
<dt>For each general entity reference in an attribute value or in the content
of an element
  <dd><p>Process as follows:
    <ol>
    <li>If the <code>Name</code> of the entity reference is either
    <code>amp</code>, <code>lt</code>, <code>gt</code>, <code>quot</code>,
    or <code>apos</code>, then abort these steps.
    <li>If the declaration for the entity is <em>not</em> processed,
    then:
      <dl class=switch>
      <dt>If the document contains no external entity or if the document
      contains the <code>standalone</code> pseudo-attribute set to
      <code>yes</code><!-- or the document contains no DTD -->
        <dd>The parser <em class=rfc2119>MUST</em> raise an
        <a href="#xml-well-formedness-error" id=wf-entdeclared-ge><code>xml-well-formedness-error</code></a>.
      <dt>Otherwise
        <dd>The parser <em class=rfc2119>MUST</em> raise an
        <a href="#xml-validity-error" id=vc-entdeclared-ge><code>xml-validity-error</code></a>.
      </dl>
    <li>If the declaration for the entity <em>is</em> processed but the
    referenced entity cannot be retrieved, then the parser
    <em class=rfc2119>MUST</em> raise an
    <span class=ed>@@ ??-error</span>.
    </ol>

    <p>In any of two cases above, process as follows:
    <ul>
    <li>If the general entity reference is the first reference to an entity
    that is not read, then the parser <em class=rfc2119>MUST</em> raise an
    <a href="#entity-error" id=ee-unread-ge><code>entity-error</code></a>.
    <span class=ed>@@ entity declared WFC?</span>
    <li class=ed>An unexpended entity reference node <em class=rfc2119>MUST</em> be inserted to the current node.
    </ul>

<dt>For each comment <em>outside</em> of document type declaration
  <dd>A <code>Comment</code> node <em class=rfc2119>MUST</em> be created
  and inserted appropriately.
  <!-- In XML 1.0/1.1 spec, this is optional. -->
</dl>

<p>The parser <em class=rfc2119>MUST</em> try to read any entity
referenced by general or parameter entity references<!--,--> and the
external subset entity, if any<!--, and any general entity declared-->
in the document type definition.

<p><strong>Well-formedness constraints</strong>.  When the parser
detects a voilation to one of certain well-formedness constraints, it
<em class=rfc2119>MUST</em> raise an <a
href="#xml-well-formedness-error"><code>xml-well-formedness-error</code></a>.
The list of such well-formed constraints is as follows:

<ul>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#wfc-PEinInternalSubset">Well-formedness constraint: PEs in Internal Subset</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#GIMatch">Well-formedness constraint: Element Type Match</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#uniqattspec">Well-formedness constraint: Unique Att Spec</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#NoExternalRefs">Well-formedness constraint: No External Entity References</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#CleanAttrVals">Well-formedness constraint: No &lt; in Attribute Values</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#wf-Legalchar">Well-formedness constraint: Legal Character</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#textent">Well-formedness constraint: Parsed Entity</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#norecursion">Well-formedness constraint: No Recursion</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#indtd">Well-formedness constraint: In DTD</a>
</ul>

<p><strong>Validity constraints</strong>.  When the parser detects a
violation to one of certain validity contraints, it <em
class=rfc2119>MUST</em> raise an <a
href="#xml-validity-error"><code>xml-validity-error</code></a>.  The
list of such validity constraints is as follows:

<ul>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#vc-PEinMarkupDecl">Validity constraint: Proper Declaration/PE Nesting</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#vc-PEinGroup">Validity constraint: Proper Group/PE Nesting</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#condsec-nesting">Validity constraint: Proper Conditional Section/PE Nesting</a>
<li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#vc-check-rmd">Validity constraint: Standalone Document Declaration</a>
</ul>

<p><strong>Other creteria</strong>.  If the parser detects a violation
to one of certain additional constraints, it <em
class=rfc2119>MUST</em> raise an <a
href="#xml-misc-recommendation"><code>xml-misc-recommendation</code></a>.
The list of such constraints is as follows:

<ul>
<li><q>For interoperability, if a parameter-entity reference appears in a 
<code>choice</code>, <code>seq</code>, or <code>Mixed</code> construct, its 
replacement text <em class=rfc2119>SHOULD</em> contain at least one non-blank 
character, and neither the first nor last non-blank character of the 
replacement text <em class=rfc2119>SHOULD</em> be a connector (<code>|</code> 
or <code>,</code>).</q>
<li><q>External parsed entities <em class=rfc2119>SHOULD</em> each begin with a
text declaration.</q>
</ul>

<p>The parser <em class=rfc2119>MUST</em> act as if it is a <a
href="http://www.w3.org/TR/2006/REC-xml-20060816/#dt-validating">validating
XML processor</a> for the purpose of informing of white space
characters appearing in <a
href="http://www.w3.org/TR/2006/REC-xml-20060816/#dt-elemcontent">element
content</a> (See <a
href="http://www.w3.org/TR/2006/REC-xml-20060816/#sec-white-space">Section
2.10</a> of the XML specification).

  <div class="note memo informative">
  <p>In other word, the <code>isElementContentWhitespace</code> attribute
  of <code>Text</code> nodes has to be set appropriately.  Note that the
  value of the attribute will be set to <code>false</code> for any 
  <code>Text</code> node in the content of an element whose declaration
  is not processed.
  </div>

<p>The parser <em class=rfc2119>MUST</em> raise at least one <a
href="#xml-well-formedness-error"
id=wfe-syntax><code>xml-well-formedness-error</code></a> if the entity
it parses does not match to the appropriate production rule in the XML
specification.  As an exception to this requirement, it <em
class=rfc2119>MAY</em> choose not to raise such an error if the error
will be raised by the conformance checker when the conformance checker
<a href="#algorithm-to-check-a-node" title="check a node">checks</a>
the <code>Document</code> object produced by the parser.

<!--
  <li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#ExtSubset">Well-formedness constraint: External Subset</a>
  <li><a href="http://www.w3.org/TR/2006/REC-xml-20060816/#PE-between-Decls">Well-formedness constraint: PE Between Declarations</a>
-->

<!--
  Inpossible to test:
    "In the absence of external character encoding information (such as MIME
    headers), parsed entities which are stored in an encoding other than UTF-8
    or UTF-16 MUST begin with a text declaration"
-->
</div>

<div class="section" id=checking-dom>
<h2>Checking an <abbr>XML</abbr> <abbr>DOM</abbr> Tree</h2>

<p>The following algorithms and definitions are applied to
<abbr>XML</abbr> documents; especially, they are not applied
to <abbr>HTML</abbr> documents.<!-- TODO: ref to HTML5 --></p>

<div class=section id=definitions>
<h3>Definitions</h3>

<p>The <dfn id=xml-version><abbr>XML</abbr> version</dfn> of a node is 
the <abbr>XML</abbr> version of the document to which the node belongs.
For a <code>Documemt</code> node, the <abbr>XML</abbr> version
of the document is the value of the <code>xmlVersion</code>
attribute of the node.  For a <code>DocumentType</code> node whose 
<code>ownerDocument</code> attribute is set to <code>null</code>,
the <abbr>XML</abbr> version of the document is <code>1.0</code><!--
since createDocumentType [DOM3CORE] assumes XML 1.0 [XML10TE] -->.
For any other node, the <abbr>XML</abbr> version of the document
is that of the <code>Document</code> node contained in the
<code>ownerDocument</code> attribute of the node.</p>

</div>


<div class=section id=checking-components>
<h3>Conformance Checking Algorithms for Components</h3>

<p>To
<dfn id=algorithm-to-validate-an-xml-character-data title="validate an XML string">to
validate an <abbr>XML</abbr> string (<dfn id=var-s><var>s</var></dfn>)</dfn>,
the following algorithm <em class=rfc2119>MUST</em> be used:</p>
<ol>
<li>If <var>s</var> contains a character that is <em>not</em> in
the character class <a href="#class-Char10"><code>Char10</code></a>, 
then raise an
<a href="#xml-well-formedness-error" id=wfe-illegal-char><code>xml-well-formedness-error</code></a>.</li>
<li>If <var>s</var> contains a character that is in the character
class <a href="#class-CompatChar10"><code>CompatChar10</code></a>,
then raise an
<a href="#xml-misc-warning" id=xmw-compat-char><code>xml-misc-warning</code></a>.</li>
<li>If <var>s</var> contains a character that is in the character
class <a href="#class-ControlChar10"><code>ControlChar10</code></a>,
then raise an
<a href="#xml-misc-warning" id=xmw-control-char><code>xml-misc-warning</code></a>.</li>
<li class=ed>@@ XML 1.1 support</li>
<li>If <var>s</var> contains a <code class=char>U+000D</code>
<code class=charname>CARRIAGE RETURN</code> character, then
raise a 
<a href="#round-trip-error" id=rte-cr><code>round-trip-error</code></a>.
<span class=ed>@@ We should not raise duplicate errors for U+000D
in attribute values.  In addition, we should support a mode where
U+000D will be serialized as &#x000D; (so that no round-trip-error
will be raised).</span></li>
</ol>

<p>To
<dfn id=algorithm-to-validate-a-name title="validate a Name">validate a
<code>Name</code> (<dfn id=var-name-s><var>s</var></dfn>)</dfn>, the following
algorithm <em class=rfc2119>MUST</em> be used:</p>
<ol>
<li>If <var>s</var> is an empty string, then raise an
<a href="#xml-well-formedness-error" id=wfe-name-empty><code>xml-well-formedness-error</code></a>.
Abort these steps.</li>
<li><a href="#algorithm-to-validate-an-xml-character-data" title="validate an XML string">Validate
<var>s</var> as an <abbr>XML</abbr> string</a>.</li>
<li>If the first character in <var>s</var> is a character that is 
<em>not</em> in the character class 
<a href="#class-NameStartChar10"><code>NameStartChar10</code></a>, then raise
an
<a href="#xml-well-formedness-error" id=wfe-name-startchar><code>xml-well-formedness-error</code></a>.</li>
<li>If a character other than the first character in <var>s</var> is a 
character that is <em>not</em> in the character class 
<a href="#class-NameChar10"><code>NameChar10</code></a>, then raise an
<a href="#xml-well-formedness-error" id=wfe-name-char><code>xml-well-formedness-error</code></a>.</li>
<li>If <var>s</var> begins with the string <code>xml</code> (in any
case combination), then raise an
<a href="#xml-misc-warning" id=xmw-reserved-name><code>xml-misc-warning</code></a>.
<span class=ed>@@ except for attribute names <code>xml:lang</code>,
<code>xml:space</code><!--, <code>xml:base</code>, <code>xml:id</code>,
<code>xmlns</code>, <code>xmlns:<var>*</var></code>,
pi name <code>xml-stylesheet</code>-->.</span><!--
"names beginning with a match to (('X'|'x')('M'|'m')('L'|'l')) are reserved for standardization in this or future versions of this specification.":
xmlns, xml-stylesheet, xml:base and xml:id specifications violate to this sentense!
--></li>
<!-- COLON in Name is a lowercase "should not" in a Note of [XML10],
[XML11]. -->
<li class=ed>@@ XML 1.1 support</li>
</ol>

<p>To
<dfn id=algorithm-to-validate-an-ncname title="validate an NCName">validate
an <code>NCName</code> (<dfn id=var-ncname-s><var>s</var></dfn>)</dfn>, the
following algorithm <em class=rfc2119>MUST</em> be used:</p>
<ol>
<li><a href="#algorithm-to-validate-a-name" title="validate a Name">Validate
<var>s</var> as a <code>Name</code></a>.</li>
<li class=ed>@@</li>
</ol>

<p>To 
<dfn id=algorithm-to-validate-a-public-identifier title="validate a public identifier">validate
a public identifier (<dfn id=var-pid><var>pid</var></dfn>)</dfn>, the
following algorithm <em class=rfc2119>MUST</em> be used:</p>
<ol>
<li>If <var>pid</var> is <code>null</code>, abort these steps.</li>
<li>If <var>pid</var> contains a character that is <em>not</em> in the
character class <a href="#class-PubidChar"><code>PubidChar</code></a>, then
raise an
<a href="#xml-well-formedness-error" id=wfe-pubid-char><code>xml-well-formedness-error</code></a>.</li>
  <li>If <var>pid</var> contains one of <code class=char>U+0009</code>
  <code class=charname>CHARACTER TABULATION</code>, 
  <code class=char>U+000A</code> <code class=charname>CARRIAGE RETURN</code>,
  and <code class=char>U+000D</code> <code class=charname>LINE FEED</code>
  characters, if the first character of <var>pid</var> is
  <code class=char>U+0020</code> <code class=charname>SPACE</code> character,
  if the last character of <var>pid</var> is <code class=char>U+0020</code>
  <code class=charname>SPACE</code> character, or if there is a
  <code class=char>U+0020</code> <code class=charname>SPACE</code> character
  immediately followed by another <code class=char>U+0020</code>
  <code class=charname>SPACE</code> character in <var>pid</var>, then it is a
  <a href="#round-trip-error" id=rte-pubid-space><code>round-trip-error</code></a>.
  <span class=ed>Is this really a roundtripness problem?  XML spec
  does only define the way to match public identifiers in fact, no
  canonical form.</span></li>
</ol>

<p>To 
<dfn id=algorithm-to-validate-a-system-identifier title="validate a system identifier">validate
a system identifier (<dfn id=var-sid><var>sid</var></dfn>)</dfn>, the
following algorithm <em class=rfc2119>MUST</em> be used:</p>
<ol>
  <li>If <var>sid</var> is <code>null</code>, abort these steps.</li>
<li><a href="#algorithm-to-validate-an-xml-character-data" title="validate an XML string">Validate
<var>sid</var> as an <abbr>XML</abbr> string</a>.</li>
  <li>If <var>sid</var> contains both <code class=char>U+0022</code>
  <code class=charname>QUOTATION MARK</code> (<code class=char>"</code>) and
  <code class=char>U+0027</code> <code class=charname>APOSTROPHE</code>
  (<code class=char>'</code>) characters, raise an
  <a href="#xml-well-formedness-error" id=wfe-sid-lit><code>xml-well-formedness-error</code></a>.</li>
  <li>If <var>sid</var> contains at least one <code class=char>U+0023</code>
  <code class=charname>NUMBER SIGN</code> (<code class=char>#</code>)
  character, then raise an
  <a href="#xml-misc-error" id=xme-sid-fragment><code>xml-misc-error</code></a>.</li>
  <li class=ed>@@ If <var>sid</var> cannot be converted to a URI
  reference, then raise a fact-level error (xml-misc-warning?).<!--
  XML 1.0 has no conformance language for system identifier being
  a URI reference. --></li>
</ol>

</div>

<div class=section id=checking-node>
<h3>Checking <code>Node</code></h3>

<p>The algorithm <dfn title="to check a node" id=algorithm-to-check-a-node>to 
check a node (<dfn id=var-n><var>n</var></dfn>)</dfn> is defined as 
following:</p>
<dl class=switch>
<dt>If <var>n</var> is an <code>Attr</code> node</dt>
  <dd>
    <ol>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>localName</code> attribute value as an <code>NCName</code></a>.</li>
    <li>If the <code>prefix</code> attribute value is different from
    <code>null</code>, then <a href="#algorithm-to-validate-an-ncname">validate
    the <code>prefix</code> attribute value as an <code>NCName</code></a>.</li>
    <li>For each node <dfn id=var-attr-nc><var>n<sub><var>c</var></sub></var></dfn> in the
    <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> a
      <code>Text</code> or <code>EntityReference</code> node, then it is an
      <a href="#xml-well-formedness-error" id=wfe-attr-child><code>xml-well-formedness-error</code></a>.</li>
      <li>Otherwise, if <var>n<sub><var>c</var></sub></var> is an
      <code>EntityReference</code> node, then it is an 
      <a href="#entity-error" id=ee-attr-er><code>entity-error</code></a>.</li>
      <li>Otherwise,
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recusrively.</li>
      </ol></li>
    <li>If <code>nodeName</code> attribute of <var>n</var> is
    <code>xml:space</code> <span class=ed>@@ or {xml namespace}:space ?</span>
    and <code>value</code> attribute of <var>n</var> is neither 
    <code>default</code> nor <code>preserve</code>, then it is an
    <a href="#xml-misc-error" id=xme-attr-xml-space><code>xml-misc-error</code></a>.<!--
    Note that <!ATTLIST e xml:space (default|preserve) "a">...
    <e xml:space="default"/> is conforming and valid. --></li>
    <li class=ed>@@ xml:lang value is not a language tag [RFC 3066 or its
    successor] or an empty string, then xml-misc-warning
    (a "fact"-level error; not an XML error).</li>
    <li class=ed>@@ <code>specified</code>,
    <code>manakaiAttributeType</code> (#ValueType Validity constraint: Attribute Value Type)</li>
    <!-- xml:space MUST be declared to be valid. -->
    <li>Let <dfn id=var-v><var>v</var></dfn> be the value of the
    attribute <code>value</code> of <var>n</var>.</li>
    <li>Validate the <var>n</var> against the <span class=ed>declared 
    type</span> as following:
      <dl class=switch>
      <dt class=ed><code>ID_ATTR</code></dt>
        <dd>
          <ol>
          <li><span class=ed>Validate <var>v</var> as an
          <code>Name</code>.</span>  If it fails, then raise an
          <a href="#xml-validity-error" id=vc-id-name><code>xml-validity-error</code></a>.</li>
          <li><span class=ed>If <code>ID</code> <var>v</var> is defined,</span>
          then raise an  
          <a href="#xml-validity-error" id=vc-id-duplication><code>xml-validity-error</code></a>.</li>
          </ol>
        </dd>
      <dt class=ed>IDREF_ATTR</dt>
        <dd>
          <ol>
          <li><span class=ed>Validate <var>v</var> as an
          <code>Name</code>.</span>  If it fails, then raise an
          <a href="#xml-validity-error" id=vc-idref-name><code>xml-validity-error</code></a>.</li>
          <li><span class=ed>If <code>ID</code> <var>v</var> is NOT
          defined,</span> then raise an  
          <a href="#xml-validity-error" id=vc-idref-match><code>xml-validity-error</code></a>.</li>
          </ol>
        </dd>
      <dt class=ed>IDREFS_ATTR</dt>
        <dd class=ed>@@</dd>
      <dt class=ed>ENTITY_ATTR</dt>
        <dd>
          <ol>
          <li><span class=ed>Validate <var>v</var> as an
          <code>Name</code>.</span>  If it fails, then raise an
          <a href="#xml-validity-error" id=vc-entname-name><code>xml-validity-error</code></a>.</li>
          <li><span class=ed>If <code>Entity</code> <var>v</var> is NOT
          defined,</span> then raise an  
          <a href="#xml-validity-error" id=vc-entname-match><code>xml-validity-error</code></a>.</li>
          </ol>
        </dd>
      <dt class=ed>ENTITIES_ATTR</dt>
        <dd class=ed>@@</dd>
      <dt class=ed>NMTOKEN_ATTR</dt>
        <dd>
          <ol>
          <li><span class=ed>Validate <var>v</var> as an
          <code>Nmtoken</code>.</span>  If it fails, then raise an
          <a href="#xml-validity-error" id=vc-nmtok-name><code>xml-validity-error</code></a>.</li>
          </ol>
        </dd>
      <dt class=ed>NMTOKENS_ATTR</dt>
        <dd class=ed>@@</dd>
      <dt class=ed>NOTATION_ATTR</dt>
        <dd class=ed><var>v</var> must be one of enumerated values.
        If not, then raise an
        <a href="#xml-validity-error" id=vc-notatn-match><code>xml-validity-error</code></a>.</dd>
      <dt class=ed>ENUMERATED_ATTR</dt>
        <dd class=ed><var>v</var> must be one of enumerated values.
        If not, then raise an
        <a href="#xml-validity-error" id=vc-enum><code>xml-validity-error</code></a>.</dd>
      <dt class=ed>@@</dt>
      </dl>
    </li>
    <li>If <span class=ed>type ID and default is NOT #IMPLIED or #REQUIRED</span>, then
    raise an
    <a href="#xml-validity-error" id=vc-id-default><code>xml-validity-error</code></a>.</li>
    <li class=ed>@@ #FixedAttr Validity constraint: Fixed Attribute Default</li>
    <li class=ed>@@ strict serialization error for U+000D, U+000A, and
    U+0009 characters, leading/trailing U+0020, and U+0020{2,} string?</li>
    </ol>
  </dd>
<dt>If <var>n</var> is an <code>AttributeDefinition</code> node</dt>
  <dd>
    <ol>
    <li class=ed></li>
    <li>If <code>nodeName</code> attribute of <var>n</var> is
    <code>xml:space</code> <span class=ed>@@ or {xml namespace}:space ?</span>
    and <span class=ed>its declared type is different from (default|preserve),
    (preserve|default), (default), or (preserve)</span>, then raise an
    <a href="#xml-misc-error" id=xme-at-xml-space><code>xml-misc-error</code></a>.</li>
    <li>For each node <dfn id=var-ad-nc><var>n<sub><var>c</var></sub></var></dfn> in the
    <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> a
      <code>Text</code> or <code>EntityReference</code> node, then it is an
      <a href="#xml-well-formedness-error" id=wfe-at-child><code>xml-well-formedness-error</code></a>.</li>
      <li>Otherwise, if <var>n<sub><var>c</var></sub></var> is an
      <code>EntityReference</code> node, then it is an 
      <a href="#entity-error" id=ee-at-er><code>entity-error</code></a>.</li>
      <li>Otherwise,
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recusrively.</li>
      </ol></li>
    <li class=ed>If <code>NOTATION_ATTR</code>, enumerated values MUST
    be declared.  If not, then raise an
    <a href="#xml-validity-error" id=vc-notatn-declared><code>xml-validity-error</code></a>.</li>
    <li class=ed>If <code>NOTATION_ATTR</code> or <code>ENUMERATED_ATTR</code>,
    values MUST all be distinct.  If not, then raise an
    <a href="#xml-validity-error" id=vc-no-duplicate-tokens><code>xml-validity-error</code></a>.</li>
    <li class=ed>If <code>NOTATION_ATTR</code> on an <code>EMPTY</code> 
    element, then raise an
    <a href="#xml-validity-error" id=vc-no-notation-empty><code>xml-validity-error</code></a>.</li>
    <li class=ed>@@ #defattrvalid Validity constraint: Attribute Default Value Syntactically Correct</li>
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>CDATASection</code> node</dt>
  <dd>
    <ol>
    <li><a href="#algorithm-to-validate-an-xml-character-data" title="validate an XML string">Validate the 
    <code>data</code> attribute value as an <abbr>XML</abbr> character
    data</a>.</li>
    <li>If the <code>data</code> attribute value contains
    a string <code>]]></code>, then raise an
    <a href="#xml-well-formedness-error" id=wfe-cs-mse><code>xml-well-formedness-error</code></a>.<!-- "for compatibility" --></li>
    <li>If the <code>childNodes</code> list of <var>n</var> contains
    any nodes, they are in
    <a href="#xml-well-formedness-error" id=wfe-cs-child><code>xml-well-formedness-error</code></a>.</li>
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>Comment</code> node</dt>
  <dd>
    <ol>
    <li>Raise an
    <a href="#round-trip-warning" id=rtw-comment><code>round-trip-warning</code></a>.</li>
    <li><a href="#algorithm-to-validate-an-xml-character-data" title="validate an XML string">Validate the 
    <code>data</code> attribute value as an <abbr>XML</abbr> character
    data</a>.</li>
    <li>If the <code>data</code> attribute value contains
    a string <code>--</code>, or if it ends with a character
    <code>-</code>, then raise an
    <a href="#xml-well-formedness-error" id=wfe-comment-com><code>xml-well-formedness-error</code></a>.<!--
    "for compatibility" --></li>
    <li>If the <code>childNodes</code> list of <var>n</var> contains
    any nodes, they are in
    <a href="#xml-well-formedness-error" id=wfe-comment-child><code>xml-well-formedness-error</code></a>.</li>
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>Document</code> node</dt>
  <dd>
    <ol>
    <li>If <a href="#xml-version"><abbr>XML</abbr> version</a> of <var>n</var>
    is different from <code>1.0</code> or <code>1.1</code>,
    then it is an <code class=ed>unknown-error?</code>.</li>
    <li>If the <code>xmlEncoding</code> attribute value does <em>not</em>
    match to <code>[A-Za-z] ([A-Za-z0-9._] | '-')*</code>
    <span class=ed>@@ formal def</span>, then it is an
    <a href="#xml-well-formedness-error" id=wfe-encoding><code>xml-well-formedness-error</code></a>.</li>
    <li>The <code>childNodes</code> list of <var>n</var> have to
    consist of zero or more <code>Comment</code> and/or
    <code>ProcessingInstruction</code> nodes, followed by
    an optional <code>DocumentType</code> node, followed
    by zero or more <code>Comment</code> and/or
    <code>ProcessingInstruction</code> nodes, followed by
    an <code>Element</code> node, followed
    by zero or more <code>Comment</code> and/or
    <code>ProcessingInstruction</code> nodes.  Any violation to this is an
    <a href="#xml-well-formedness-error" id=wfe-document-child><code>xml-well-formedness-error</code></a>.</li>
    <li>For each node <dfn id=var-document-nc><var>n<sub><var>c</var></sub></var></dfn>
    in the <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> an
      <code>EntityReference</code> node, then
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recursively.</li>
      </ol></li>
    <li class=ed>@@ <code>allDeclarationsProcessed</code></li>
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>DocumentFragment</code> node</dt>
  <dd>
    <ol>
    <li>For each node <dfn id=var-df-nc><var>n<sub><var>c</var></sub></var></dfn>
    in the <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> an
      <code>Element</code>, <code>Text</code>, <code>CDATASection</code>,
      <code>Comment</code>, <code>ProcessingInstruction</code>, or
      <code>EntityReference</code> node, then it is an
      <a href="#xml-well-formedness-error" id=wfe-df-child><code>xml-well-formedness-error</code></a>.</li>
      <li>Otherwise, if <var>n<sub><var>c</var></sub></var> is an
      <code>EntityReference</code> node, then it is an
      <a href="#entity-error" id=ee-df-er><code>entity-error</code></a>.</li>
      <li>Otherwise,
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recursively.</li>
      </ol></li>
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>DocumentType</code> node</dt>
  <dd>
    <ol>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>nodeName</code> attribute value as an <code>NCName</code></a>.</li>
    <li>Follow the following substeps:
      <ol>
      <li>If <code>ownerDocument</code> attribute of <var>n</var> is
      <code>null</code>, then abort these substeps.</li>
      <li>If <code>documentElement</code> attribute of the node
      set to <code>ownerDocument</code> attribute of <var>n</var> is
      <code>null</code>, then abort these substeps.</li>
      <li>If <code>nodeName</code> attribute of the node set to
      <code>documentElement</code> attribute of the node set to
      <code>ownerDocument</code> attribute of <var>n</var> is
      different from <code>nodeName</code> of <var>n</var>,
      then raise an
      <a href="#xml-validity-error" id=vc-roottype><code>xml-validity-error</code></a>.</li></li>
      </ol>
    </li>
    <li><a href="#algorithm-to-validate-a-public-identifier" title="validate a public identifier">Validate
    the <code>publicId</code> attribute value as a public identifier</a>.</li>
    <li><a href="#algorithm-to-validate-a-system-identifier" title="validate a system identifier">Validate
    the <code>systemId</code> attribute value as a system identifier</a>.</li>
    <li>If the <code>publicId</code> attribute value of <var>n</var> is
    <em>not</em> <code>null</code> and the <code>systemId</code> attribute
    value of <var>n</var> is <code>null</code>, then raise an
    <a href="#xml-well-formedness-error" id=wfe-dt-sid><code>xml-well-formedness-error</code></a>.
    <span class=ed>@@ publicId == null?  Or, publicId == ""</span></li>
    <li>For each node <dfn id=var-dt-nc><var>n<sub><var>c</var></sub></var></dfn>
    in the <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> a
      <code>ProcessingInstruction</code> node, then it is an
      <a href="#xml-well-formedness-error" id=wfe-dt-child><code>xml-well-formedness-error</code></a>.
      <span class=ed>@@ ref to manakai's extensions</span></li>
      <li>Otherwise, <!-- if n_c is not an EntityReference node, -->
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recusrively.</li>
      </ol></li>
    <li>For each node in the <code>entities</code>, <code>notations</code>,
    and <code>elementTypes</code> lists of <var>n</var>,
    <a href="#algorithm-to-check-a-node" title="check a node">check the
    node</a> recursively.</li>
    <li class=ed>@@ externally declared?</li>
    <li>If the <code>NamedNodeMap</code> object in the <code>entities</code>
    attribute of <var>n</var> does not contain <code>Entity</code> nodes
    whose <code>nodeName</code> attribute are <code>amp</code>,
    <code>lt</code>, <code>gt</code>, <code>apos</code>, and <code>quot</code>
    then raise
    <a href="#xml-misc-recommentation" id=xmr-predefined><code>xml-misc-recommendation</code></a>(s).
    </ol>
  </dd>
<dt>If <var>n</var> is an <code>Element</code> node</dt>
  <dd>
    <ol>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>localName</code> attribute value as an <code>NCName</code></a>.</li>
    <li>If the <code>prefix</code> attribute value is different from
    <code>null</code>, then <a href="#algorithm-to-validate-an-ncname">validate
    the <code>prefix</code> attribute value as an <code>NCName</code></a>.</li>
    <li>For each node <dfn id=var-element-nc><var>n<sub><var>c</var></sub></var></dfn>
    in the <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> an 
      <code>Element</code>,
      <code>Text</code>, <code>CDATASection</code>, <code>Comment</code>,
      <code>ProcessingInstruction</code>, or
      <code>EntityReference</code> node, then it is an
      <a href="#xml-well-formedness-error" id=wfe-element-child><code>xml-well-formedness-error</code></a>.</li>
      <li>Otherwise, if <var>n<sub><var>c</var></sub></var> is an
      <code>EntityReference</code> node, then it is an
      <a href="#entity-error" id=ee-element-er><code>entity-error</code></a>.</li>
      <li>Otherwise,
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recursively.</li>
      </ol></li>
    <li class=ed>@@ #elementvalid Validity constraint: Element Valid</li>
    <li>Let <var>attrs</var> be the value of the <code>attribute</code>
    attribute of <var>n</var>.  Check conformance of <var>attrs</var>
    as following:
      <ol>
      <li>If <var>attrs</var> contains an <code>Attr</code> node whose
      <code>nodeName</code> attribute value is equal to that of another
      <code>Attr</code> node in <var>attrs</var>, then raise an
      <a href="#xml-well-formedness-error" id=wfe-uniqattspec><code>xml-well-formedness-error</code></a>.<!--
      #uniqattspec Well-formedness constraint: Unique Att Spec --></li>
      <li class=ed>@@ #RequiredAttr Validity constraint: Required Attribute</li>
      </ol>
    </li>
    </ol>
  </dd>
<dt>If <var>n</var> is an <code>ElementTypeDefinition</code> node</dt>
  <dd>
    <ol>
    <li class=ed></li>
    <li>If the <code>childNodes</code> list of <var>n</var> contains
    any nodes, they are in
    <a href="#xml-well-formedness-error" id=wfe-et-child><code>xml-well-formedness-error</code></a>.</li>
    <li class=ed>@@ <q cite="http://www.w3.org/TR/2006/REC-xml-20060816/#elemdecls">At user option, an XML processor MAY issue a warning when a declaration mentions an element type for which no declaration is provided, but this is not an error.</q></li>
    <li class=ed>@@ <q cite="http://www.w3.org/TR/2006/REC-xml-20060816/#sec-element-content">For compatibility, it is an error if the content model allows an element to match more than one occurrence of an element type in the content model. </q></li>
    <li class=ed>@@ #vc-MixedChildrenUnique
    Validity constraint: No Duplicate Types</li>
    <li class=ed>@@ <q cite="http://www.w3.org/TR/2006/REC-xml-20060816/#attdecls">At user option, an XML processor MAY issue a warning if attributes are declared for an element type not itself declared, but this is not an error.</q></li>
    <li>If there is more than one <code>AttributeDefinition</code> node
    with <span class=ed>attribute type <code>ID</code></span> in the 
    <code>NamedNodeMap</code> list contained in the 
    <code>attributeDefinitions</code> attribute of <var>n</var>, then raise an
    <a href="#xml-validity-error" id=vc-one-id-per-el><code>xml-validity-error</code></a>.</li>
    <li>If there is more than one <code>AttributeDefinition</code> node
    with <span class=ed>attribute type <code>NOTATION</code></span> in the 
    <code>NamedNodeMap</code> list contained in the 
    <code>attributeDefinitions</code> attribute of <var>n</var>, then raise an
    <a href="#xml-validity-error" id=vc-one-notation-per><code>xml-validity-error</code></a>.</li>
    <li class=ed>"For interoperability, the same Nmtoken  SHOULD NOT occur more than once in the enumerated attribute types of a single element type."</li>
    </ol>
  </dd>
<dt>If <var>n</var> is an <code>Entity</code> node whose
<code>notationName</code> attribute value is <code>null</code> (i.e. a
parsed entity)</dt>
  <dd>
    <ol>
    <li>Raise an
    <a href="#entity-error" id=ee-entity-node><code>entity-error</code></a>.</li>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>nodeName</code> attribute value as an <code>NCName</code></a>.</li>
    <li><a href="#algorithm-to-validate-a-public-identifier" title="validate a public identifier">Validate
    the <code>publicId</code> attribute value as a public identifier</a>.</li>
    <li><a href="#algorithm-to-validate-a-system-identifier" title="validate a system identifier">Validate
    the <code>systemId</code> attribute value as a system identifier</a>.</li>
    <li>If the <code>publicId</code> attribute value of <var>n</var> is
    <em>not</em> <code>null</code> and the <code>systemId</code> attribute
    value of <var>n</var> is <code>null</code>, then raise an
    <a href="#xml-well-formedness-error" id=wfe-entity-sid><code>xml-well-formedness-error</code></a>.</li>
    <li>For each node <dfn id=var-entity-nc><var>n<sub><var>c</var></sub></var></dfn>
    in the <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> an
      <code>Element</code>,
      <code>Text</code>, <code>CDATASection</code>, <code>Comment</code>,
      <code>ProcessingInstruction</code>, or <code>EntityReference</code>
      node, then it is an
      <a href="#xml-well-formedness-error" id=wfe-entity-child><code>xml-well-formedness-error</code></a>.</li>
      <li>Otherwise, if <var>n<sub><var>c</var></sub></var> is an
      <code>EntityReference</code> node, then it is an
      <a href="#entity-error" id=ee-er-er><code>entity-error</code></a>.</li>
      <li>Otherwise,
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recursively.</li>
      </ol></li>
    </ol>
  </dd>
<dt>If <var>n</var> is an <code>Entity</code> node whose
<code>notationName</code> attribute value is <em>not</em> <code>null</code>
(i.e. an unparsed entity)</dt>
  <dd>
    <ol>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>nodeName</code> attribute value as an <code>NCName</code></a>.</li>
    <li><a href="#algorithm-to-validate-a-public-identifier" title="validate a public identifier">Validate
    the <code>publicId</code> attribute value as a public identifier</a>.</li>
    <li><a href="#algorithm-to-validate-a-system-identifier" title="validate a system identifier">Validate
    the <code>systemId</code> attribute value as a system identifier</a>.</li>
    <li>If the <code>systemId</code> attribute value of <var>n</var> is
    <code>null</code>, then raise an
    <a href="#xml-well-formedness-error" id=wfe-uentity-sid><code>xml-well-formedness-error</code></a>.</li>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>notationName</code> attribute value of <var>n</var> as an
    <code>NCName</code></a>.</li>
    <li class=ed>@@ #not-declared Validity constraint: Notation Declared</li>
    <li>If the <code>childNodes</code> list of <var>n</var> contains
    any nodes, they are in
    <a href="#xml-well-formedness-error" id=wfe-uentity-child><code>xml-well-formedness-error</code></a>.</li>
    </ol>
  </dd>
<dt>If <var>n</var> is an <code>EntityReference</code> node</dt>
  <dd>
    <ol>
    <li>An <a href="#entity-error" id=ee-er-node><code>entity-error</code></a>.</li>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>nodeName</code> attribute value as an <code>NCName</code></a>.</li>
    <li>For each node <dfn id=var-er-nc><var>n<sub><var>c</var></sub></var></dfn>
    in the <code>childNodes</code> list of <var>n</var>,
      <ol>
      <li>If <var>n<sub><var>c</var></sub></var> is <em>not</em> an
      <code>Element</code>,
      <code>Text</code>, <code>CDATASection</code>, <code>Comment</code>,
      <code>ProcessingInstruction</code>, or <code>EntityReference</code>
      node, then it is an
      <a href="#xml-well-formedness-error" id=wfe-er-child><code>xml-well-formedness-error</code></a>.</li>
      <li>Otherwise, if <var>n<sub><var>c</var></sub></var> is <em>not</em> an
      <code>EntityReference</code> node, then it is an 
      <a href="#entity-error" id=ee-entity-er><code>entity-error</code></a>.</li>
      <li>Otherwise,
      <a href="#algorithm-to-check-a-node" title="check a node">check
      <var>n<sub><var>c</var></sub></var></a> recursively.</li>
      </ol></li>
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>Notation</code> node</dt>
  <dd>
    <ol>
    <li><a href="#algorithm-to-validate-an-ncname">Validate the
    <code>nodeName</code> attribute value as an <code>NCName</code></a>.</li>
    <li><a href="#algorithm-to-validate-a-public-identifier" title="validate a public identifier">Validate
    the <code>publicId</code> attribute value as a public identifier</a>.</li>
    <li><a href="#algorithm-to-validate-a-system-identifier" title="validate a system identifier">Validate
    the <code>systemId</code> attribute value as a system identifier</a>.</li>
    <li>If the <code>childNodes</code> list of <var>n</var> contains
    any nodes, they are in
    <a href="#xml-well-formedness-error" id=wfe-notation-child><code>xml-well-formedness-error</code></a>.</li>
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>ProcessingInstruction</code> node</dt>
  <dd>
    <ol>
    <li>If the <code>target</code> attribute value matches to the string
    <code>xml</code> in any case combination, then raise a 
    <a href="#xml-well-formedness-error" id=wfe-pi-xml><code>xml-well-formedness-error</code></a>.</li>
    <li>Otherwise, <a href="#algorithm-to-validate-an-ncname">validate the
    <code>target</code> attribute value as an <code>NCName</code></a>.</li>
    <li>Then,
    <a href="#algorithm-to-validate-an-xml-character-data" title="validate an XML string">validate
    the <code>data</code> attribute value as an <abbr>XML</abbr> character
    data</a>.</li>
    <li>If the <code>data</code> attribute value contains a string
    <code>?></code>, then raise a 
    <a href="#xml-well-formedness-error" id=wfe-pi-pic><code>xml-well-formedness-error</code></a>.</li>
    <li>If the <code>data</code> attribute value starts with either
    <code class=char>U+0009</code> <code class=charname>CHARACTER
    TABULATION</code>, <code class=char>U+000A</code> <code class=charname>LINE
    FEED</code>, <code class=char>U+000D</code> <code class=charname>CARRIAGE
    RETURN</code>, or <code class=char>U+0020</code>
    <code class=charname>SPACE</code> character, then raise a
    <a href="#round-trip-error" id=rte-pi-s><code>round-trip-error</code></a>.</li>
    <li>If the <code>childNodes</code> list of <var>n</var> contains
    any nodes, then raise an
    <a href="#xml-well-formedness-error" id=wfe-pi-child><code>xml-well-formedness-error</code></a>.</li>
    <li class=ed>@@ Warn if not declared
    </ol>
  </dd>
<dt>If <var>n</var> is a <code>Text</code> node</dt>
  <dd>
    <ol>
    <li><a href="#algorithm-to-validate-an-xml-character-data" title="validate an XML string">Validate the 
    <code>data</code> attribute value as an <abbr>XML</abbr> character
    data</a>.</li>
    <li>If the <code>childNodes</code> list of <var>n</var> contains
    any nodes, they are in
    <a href="#xml-well-formedness-error" id=wfe-text-child><code>xml-well-formedness-error</code></a>.</li>
    </ol>
  </dd>
<dt>Otherwise</dt>
  <dd><span class=ed>xml-well-formedness-error?  unknown-error?</span></dd>
</dl>

</div>

</div>

<div id=classes class=section>
<h2>Character Classes</h2>

<p>This section defines a couple of character classes.
These classes are referred to by algorithms specified above.</p>

<p>Character class <dfn id=class-Char10><code>Char10</code></dfn> 
contains the following characters:</p>
<ul>
<li><code class=char>U+0009</code> <code class=charname>CHARACTER
TABULATION</code></li>
<li><code class=char>U+000A</code> <code class=charname>LINE FEED</code></li>
<li><code class=char>U+000D</code> <code class=charname>CARRIAGE
RETURN</code></li>
<li><code class=char>U+0020</code> <code class=charname>SPACE</code>
.. <code class=char>U+D7FF</code></li>
<li><code class=char>U+E000</code> .. <code class=char>U+FFFD</code>
<code class=charname>REPLACEMENT CHARACTER</code></li>
<li><code class=char>U+10000</code> .. <code class=char>U+10FFFF</code></li>
</ul>
<div class="note memo">
<p>This character class contains all characters allowed in the production rule
<a href="http://www.w3.org/TR/2006/REC-xml-20060816/#NT-Char"><code>Char</code></a>
of <abbr>XML</abbr> 1.0
<cite class="bibref normative">[<a href="#ref-XML10">XML10</a>]</cite>.</p>
</div>

<p>Character class <dfn id=class-CompatChar10><code>CompatChar10</code></dfn> 
contains the following characters:</p>
<ul>
<li class=ed>@@ <q>Document authors are encouraged to avoid "compatibility characters", as defined in section 6.8 of [Unicode @@ Unicode 2.0 @@] (see also D21 in section 3.6 of [Unicode3]).</q></li>
</ul>

<p>Character class <dfn id=class-ControlChar10><code>ControlChar10</code></dfn> 
contains the following characters:</p>
<ul>
<li><code class=char>U+007F</code> <code class=charname>DELETE</code> ..
<code class=char>U+0084</code> <code class=charname>INDEX</code></li>
<li><code class=char>U+0086</code> <code class=charname>START OF SELECTED
AREA</code> .. <code class=char>U+009F</code> <code class=charname>APPLICATION
PROGRAM COMMAND</code></li>
<li><code class=char>U+FDD0</code> .. <code class=char>U+FDEF</code></li>
<li><code class=char>U+1FFFE</code> .. <code class=char>U+1FFFF</code></li>
<li><code class=char>U+2FFFE</code> .. <code class=char>U+2FFFF</code></li>
<li><code class=char>U+3FFFE</code> .. <code class=char>U+3FFFF</code></li>
<li><code class=char>U+4FFFE</code> .. <code class=char>U+4FFFF</code></li>
<li><code class=char>U+5FFFE</code> .. <code class=char>U+5FFFF</code></li>
<li><code class=char>U+6FFFE</code> .. <code class=char>U+6FFFF</code></li>
<li><code class=char>U+7FFFE</code> .. <code class=char>U+7FFFF</code></li>
<li><code class=char>U+8FFFE</code> .. <code class=char>U+8FFFF</code></li>
<li><code class=char>U+9FFFE</code> .. <code class=char>U+9FFFF</code></li>
<li><code class=char>U+AFFFE</code> .. <code class=char>U+AFFFF</code></li>
<li><code class=char>U+BFFFE</code> .. <code class=char>U+BFFFF</code></li>
<li><code class=char>U+CFFFE</code> .. <code class=char>U+CFFFF</code></li>
<li><code class=char>U+DFFFE</code> .. <code class=char>U+DFFFF</code></li>
<li><code class=char>U+EFFFE</code> .. <code class=char>U+EFFFF</code></li>
<li><code class=char>U+FFFFE</code> .. <code class=char>U+FFFFF</code></li>
<li><code class=char>U+10FFFE</code> .. <code class=char>U+10FFFF</code></li>
</ul>
<div class="note memo">
<p>This character class contains the characters listed in the Note in
<a href="http://www.w3.org/TR/2006/REC-xml-20060816/#charsets">Section 2.2</a>
of <abbr>XML</abbr> 1.0
<cite class="bibref normative">[<a href="#ref-XML10">XML10</a>]</cite>,
as amended by
<a href="http://www.w3.org/XML/xml-V10-4e-errata#E02">errata</a>.</p>
</div>

<p>The character class <dfn id=class-NameStartChar10><code>NameStartChar10</code></dfn> 
contains the following characters:</p>
<ul class=ed>
</ul>
<div class="note memo">
<p>This character class contains all characters allowed as the first character
of a string matching to the production rule
<a href="http://www.w3.org/TR/2006/REC-xml-20060816/#NT-Name"><code>Name</code></a>
of <abbr>XML</abbr> 1.0
<cite class="bibref normative">[<a href="#ref-XML10">XML10</a>]</cite>.</p>
</div>

<p>The character class <dfn id=class-NameChar10><code>NameChar10</code></dfn> 
contains the following characters:</p>
<ul>
<li>The characters in the character class
<a href="#class-NameStartChar10">NameStartChar10</a>.</li>
<li class=ed></li>
</ul>
<div class="note memo">
<p>This character class contains all characters allowed as the second
character of a string matching to the production rule
<a href="http://www.w3.org/TR/2006/REC-xml-20060816/#NT-Name"><code>Name</code></a>
of <abbr>XML</abbr> 1.0
<cite class="bibref normative">[<a href="#ref-XML10">XML10</a>]</cite>.</p>
</div>

<p>The character class <dfn id=class-PubidChar><code>PubidChar</code></dfn>
contains the following characters:</p>
<ul>
<li><code class=char>U+0009</code> <code class=charname>CHARACTER 
TABULATION</code></li>
<li><code class=char>U+000A</code> <code class=charname>LINE FEED</code></li>
<li><code class=char>U+000D</code> <code class=charname>CARRIAGE
RETURN</code></li>
<li><code class=char>U+0020</code> <code class=charname>SPACE</code></li>
<li><code class=char>U+0021</code> <code class=charname>EXCLAMATION MARK</code>
(<code class=char>!</code>)</li>
<li><code class=char>U+0023</code> <code class=charname>DOLLAR SIGN</code>
(<code class=char>$</code>)</li>
<li><code class=char>U+0024</code> <code class=charname>NUMBER SIGN</code>
(<code class=char>#</code>)</li>
<li><code class=char>U+0025</code> <code class=charname>PERCENT SIGN</code>
(<code class=char>%</code>)</li>
<li><code class=char>U+0027</code> <code class=charname>APOSTROPHE</code>
(<code class=char>'</code>)</li>
<li><code class=char>U+0028</code> <code class=charname>LEFT PARENTHESIS</code>
(<code class=char>(</code>)</li>
<li><code class=char>U+0029</code> <code class=charname>RIGHT
PARENTHESIS</code> (<code class=char>)</code>)</li>
<li><code class=char>U+002A</code> <code class=charname>ASTERISK</code>
(<code class=char>*</code>)</li>
<li><code class=char>U+002B</code> <code class=charname>PLUS SIGN</code>
(<code class=char>+</code>)</li>
<li><code class=char>U+002C</code> <code class=charname>COMMA</code>
(<code class=char>,</code>)</li>
<li><code class=char>U+002D</code> <code class=charname>HYPHEN-MINUS</code>
(<code class=char>-</code>)</li>
<li><code class=char>U+002E</code> <code class=charname>FULL STOP</code>
(<code class=char>.</code>)</li>
<li><code class=char>U+002F</code> <code class=charname>SOLIDUS</code>
(<code class=char>/</code>)</li>
<li><code class=char>U+0030</code> <code class=charname>DIGIT ZERO</code>
(<code class=char>0</code>) .. <code class=char>U+0039</code>
<code class=charname>DIGIT NINE</code> (<code class=char>9</code>)</li>
<li><code class=char>U+003A</code> <code class=charname>COLON</code>
(<code class=char>:</code>)</li>
<li><code class=char>U+003B</code> <code class=charname>SEMICOLON</code>
(<code class=char>;</code>)</li>
<li><code class=char>U+003D</code> <code class=charname>EQUAL SIGN</code>
(<code class=char>=</code>)</li>
<li><code class=char>U+003F</code> <code class=charname>QUESTION MARK</code>
(<code class=char>?</code>)</li>
<li><code class=char>U+0040</code> <code class=charname>COMMERCIAL AT</code>
(<code class=char>@</code>)</li>
<li><code class=char>U+0041</code> <code class=charname>LATIN CAPITAL LETTER
A</code> (<code class=char>A</code>) .. <code class=char>U+005A</code>
<code class=charname>LATIN CAPITAL LETTER Z</code> 
(<code class=char>Z</code>)</li>
<li><code class=char>U+005F</code> <code class=charname>LOW LINE</code>
(<code class=char>_</code>)</li>
<li><code class=char>U+0061</code> <code class=charname>LATIN CAPITAL LETTER
A</code> (<code class=char>A</code>) .. <code class=char>U+007A</code>
<code class=charname>LATIN CAPITAL LETTER Z</code> 
(<code class=char>Z</code>)</li>
</ul>
<div class="note memo">
<p>This character class contains all characters allowed in the production rule
<a href="http://www.w3.org/TR/2006/REC-xml-20060816/#NT-PubidChar"><code>PubidChar</code></a>
of <abbr>XML</abbr> 1.0
<cite class="bibref normative">[<a href="#ref-XML10">XML10</a>]</cite>.</p>
</div>

</div>

<div id="references" class="section reference">
<h2>References</h2>

<div id="normative-references" class="section normative reference">
<h3>Normative References</h3>

<dl>
<dt id=ref-DOM3CORE>DOM3CORE</dt>
  <dd class=ed>@@ W3C DOM Level 3 Core</dd>
<dt id=ref-DOMDTDEF>DOMDTDEF</dt>
  <dd class=ed>@@ manakai's extension to DOM for document type definitions</dd>
<dt id="ref-KEYWORDS">KEYWORDS</dt>
  <dd><cite><a href="urn:ietf:rfc:2119">Key words for use in 
  <abbr>RFCs</abbr> to Indicate Requirement Levels</a></cite>,
  <abbr title="Internet Engineering Task Force">IETF</abbr> 
  <a href="urn:ietf:bcp:14"><abbr title="Best Current Practice">BCP</abbr> 
  14</a>, <abbr title="Request for Comments">RFC</abbr> 2119, 
  <time datetime=1997-03>March 1997</time>.
  <em>This</em> version of the specification is referenced.</dd>
<dt id=ref-INFOSET>INFOSET</dt>
  <dd class=ed>@@</dd>
<dt id=ref-XML10">XML10</dt>
  <dd><cite><a href="http://www.w3.org/TR/2006/REC-xml-20060816">Extensible
  Markup Language (<abbr>XML</abbr>) 1.0 (Fourth Edition)</a></cite>,
  <abbr>W3C</abbr> Recommendation, <time datetime=2006-08-16>16 August 
  2006</time>, edited in place <time datetime=2006-09-29>29 September
  2006</time>.  Tje latest version of the specification is available at
  <code class=uri>&lt;<a href="http://www.w3.org/TR/xml">http://www.w3.org/TR/xml</a>&gt;</code>.
  <em>This</em> version of the specification is referenced.</dd>
<dt id=ref-XML11>XML11</dt>
  <dd class=ed>@@</dd>
</dl>
</div>

<div id="informative-references" class="section informative reference">
<h3>Non$B!>(Bnormative References</h3>

<dl class=ed>
<dt id=ref-CSS>CSS</dt>
  <dd><cite><a href="http://www.w3.org/TR/2007/CR-CSS21-20070719">Cascading
  Style Sheets Level 2 Revision 1 (<abbr>CSS</abbr> 2.1)
  Specification</a></cite>, 
  <abbr title="World Wide Web Consortium">W3C</abbr> Candidate
  Recommendation, <time datetime=2007-07-19>19 July 2007</time>.
  Work in progress.  The latest version of the specification is
  available at 
  <code class=URI>&lt;<a href="http://www.w3.org/TR/CSS21">http://www.w3.org/TR/CSS21</a>></code>.</dd>
<dt id=ref-CSSOM>CSSOM</dt>
  <dd><cite><a href="http://dev.w3.org/cvsweb/~checkout~/csswg/cssom/Overview.html?rev=1.55&amp;content-type=text/html;%20charset=utf-8">Cascading
  Style Sheets Object Model (<abbr>CSSOM</abbr>)</a></cite>,
  <abbr title="World Wide Web Consortium">W3C</abbr> Editor's Draft,
  <time datetime=2007-06-18>18 June 2007</time>.  Work in progress.
  The latest Editor's Draft of the specification is available at
  <code class=URI>&lt;<a href="http://dev.w3.org/csswg/cssom/Overview.html">http://dev.w3.org/csswg/cssom/Overview.html</a>></code>.</dd>
<dt id=ref-HTML5>HTML5</dt>
  <dd><cite><a href="http://whatwg.org/html5"><abbr>HTML</abbr> 5</a></cite>,
  <abbr title="Web Hypertext Application Technology Working Group">WHATWG</abbr>
  Working Draft.  Work in progress.</dd>
<dt id=ref-SAPI>SAPI</dt>
  <dd><cite><a href="http://dev.w3.org/cvsweb/~checkout~/2006/webapi/selectors-api/Overview.html?rev=1.28&amp;content-type=text/html;%20charset=utf-8">Selectors <abbr>API</abbr></a></cite>,
  <abbr title="World Wide Web Consortium">W3C</abbr> Editor's Draft,
  <time datetime=2007-08-29>29 August 2007</time>.  Work in progress.
  The latest Editor's Draft of the specification is available at
  <code class=URI>&lt;<a href="http://dev.w3.org/2006/webapi/selectors-api/Overview.html">http://dev.w3.org/2006/webapi/selectors-api/Overview.html</a>></code>.
  The latest published version of the specification is available at
  <code class=URI>&lt;<a href="http://www.w3.org/TR/selectors-api/">http://www.w3.org/TR/selectors-api/</a>></code>.</dd>
<dt id=XBL2>XBL2</dt>
  <dd><cite><a href="http://www.mozilla.org/projects/xbl/xbl2.html"><abbr>XBL</abbr>
  2.0</a></cite>, Mozilla.org, <time datetime=2007-03-15>15 Mar 2007</time>.
  Work in progress.  The latest
  <abbr title="World Wide Web Consortium">W3C</abbr>$B!>(Bpublished
  version of the specification is available at
  <code class=URI>&lt;<a href="http://www.w3.org/TR/xbl/">http://www.w3.org/TR/xbl/</a>></code>.</dd>
<dt id=ref-XML5>XML5</dt>
  <dd class=ed>@@</dd>
</dl>
</div>

</div>

</body>
</html>