[html5] r1310 - /
whatwg at whatwg.org
whatwg at whatwg.org
Sun Mar 2 17:07:57 PST 2008
Author: ianh
Date: 2008-03-02 17:07:54 -0800 (Sun, 02 Mar 2008)
New Revision: 1310
Modified:
index
source
Log:
[e] (0) deindent the source
Modified: index
===================================================================
--- index 2008-03-03 01:02:46 UTC (rev 1309)
+++ index 2008-03-03 01:07:54 UTC (rev 1310)
@@ -42105,13 +42105,13 @@
href="#div">div</a></code> element, then stop this algorithm.
</li>
<!-- an element <foo> is in this
- list if the following markup:
+ list if the following markup:
- <!DOCTYPE html><body><ol><li><foo><li>
+ <!DOCTYPE html><body><ol><li><foo><li>
- ...results in the second <li> not being (in any way) a
- descendant of the first <li>, or if <foo> is a formatting
- element that gets reopened later. -->
+ ...results in the second <li> not being (in any way) a
+ descendant of the first <li>, or if <foo> is a formatting
+ element that gets reopened later. -->
<li>
<p>Otherwise, set <var title="">node</var> to the previous entry in the
@@ -42152,13 +42152,13 @@
href="#div">div</a></code> element, then stop this algorithm.
</li>
<!-- an element <foo> is in this
- list if the following markup:
+ list if the following markup:
- <!DOCTYPE html><body><ol><dt><foo><dt>
+ <!DOCTYPE html><body><ol><dt><foo><dt>
- ...results in the second <li> not being (in any way) a
- descendant of the first <li>, or if <foo> is a formatting
- element that gets reopened later. -->
+ ...results in the second <li> not being (in any way) a
+ descendant of the first <li>, or if <foo> is a formatting
+ element that gets reopened later. -->
<li>
<p>Otherwise, set <var title="">node</var> to the previous entry in the
@@ -42206,9 +42206,9 @@
that of the token, then pop elements from this stack until an element
with that tag name has been popped from the stack.</p>
<!-- XXX quirk (except for in certain cases?):
- <p>Otherwise, act as if a start tag with the tag name given in
- the token had been seen, then reprocess the current token.</p>
- -->
+ <p>Otherwise, act as if a start tag with the tag name given in
+ the token had been seen, then reprocess the current token.</p>
+ -->
<dt>An end tag whose tag name is "form"
@@ -42277,16 +42277,16 @@
scope</a>, then act as if an end tag with the tag name <code><a
href="#p">p</a></code> had been seen.</p>
<!-- Removed for compatibility with IE7, though all other
- browsers do it this way. If you do put this back, make
- sure to handle <h1><a><h2>, as in Webkit bug 12646.
- http://bugs.webkit.org/show_bug.cgi?id=12646
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has in scope</span> an element whose tag
- name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
- this is a <span>parse error</span>; pop elements from the
- stack until an element with one of those tag names has been
- popped from the stack.</p>
- -->
+ browsers do it this way. If you do put this back, make
+ sure to handle <h1><a><h2>, as in Webkit bug 12646.
+ http://bugs.webkit.org/show_bug.cgi?id=12646
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has in scope</span> an element whose tag
+ name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
+ this is a <span>parse error</span>; pop elements from the
+ stack until an element with one of those tag names has been
+ popped from the stack.</p>
+ -->
<p><a href="#insert" title="insert an html element">Insert an HTML
element</a> for the token.</p>
@@ -42310,14 +42310,14 @@
from the stack until an element with one of those tag names has been
popped from the stack.</p>
<!-- XXX quirk:
- <p>Otherwise, act as if a start tag with the tag name given in
- the token had been seen, then reprocess the current token.</p>
- -->
+ <p>Otherwise, act as if a start tag with the tag name given in
+ the token had been seen, then reprocess the current token.</p>
+ -->
</dd>
<!-- ADOPTION AGENCY ELEMENTS
- Mozilla-only: bdo blink del ins sub sup q
- Safari-only: code dfn kbd nobr samp var wbr
- Both: a b big em font i s small strike strong tt u -->
+ Mozilla-only: bdo blink del ins sub sup q
+ Safari-only: code dfn kbd nobr samp var wbr
+ Both: a b big em font i s small strike strong tt u -->
<dt>A start tag whose tag name is "a"
@@ -42523,9 +42523,9 @@
href="#formatting">formatting</a> category ever get cloned by this
algorithm.</p>
<!--XXX
- <div class="example">
- <p class="big-issue">Need an example.</p>
- </div>
+ <div class="example">
+ <p class="big-issue">Need an example.</p>
+ </div>
-->
<p class=note>Because of the way this algorithm causes elements to change
@@ -42637,8 +42637,8 @@
<p><a href="#parse0">Parse error</a>. Change the token's tag name to
"img" and reprocess it. (Don't ask.)</p>
<!-- As of
- 2005-12, studies showed that around 0.2% of pages used the
- <image> element. -->
+ 2005-12, studies showed that around 0.2% of pages used the
+ <image> element. -->
<dt>A start tag whose tag name is "input"
@@ -42652,7 +42652,7 @@
<p>If the <a href="#form-element"><code title="">form</code> element
pointer</a> is not null, then <span>associate</span><!--XXX
- xref! -->
+ xref! -->
the <code>input</code> element with the <code>form</code> element
pointed to by the <a href="#form-element"><code title="">form</code>
element pointer</a>.</p>
@@ -42717,10 +42717,10 @@
</dd>
<!-- XXX keygen support; don't forget form element pointer!
- <dt>A start tag whose tag name is "keygen"</dt>
- <dd>
- ...
- </dd>
+ <dt>A start tag whose tag name is "keygen"</dt>
+ <dd>
+ ...
+ </dd>
-->
<dt>A start tag whose tag name is "textarea"
@@ -42730,7 +42730,7 @@
<p>If the <a href="#form-element"><code title="">form</code> element
pointer</a> is not null, then <span>associate</span><!--XXX
- xref! -->
+ xref! -->
the <code>textarea</code> element with the <code>form</code> element
pointed to by the <a href="#form-element"><code title="">form</code>
element pointer</a>.</p>
@@ -42820,10 +42820,10 @@
element.</p>
<!--
Put the following into the MathML namespace if parsed:
- math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded,
- mphantom, mfenced, menclose, msub, msup, msubsup, munder,
- mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr,
- mtd, maction
+math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded,
+mphantom, mfenced, menclose, msub, msup, msubsup, munder,
+mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr,
+mtd, maction
-->
Modified: source
===================================================================
--- source 2008-03-03 01:02:46 UTC (rev 1309)
+++ source 2008-03-03 01:07:54 UTC (rev 1310)
@@ -38516,2561 +38516,2561 @@
-->
- <h6>The <dfn title="insertion mode: before head">before head</dfn> insertion mode</h6>
+ <h6>The <dfn title="insertion mode: before head">before head</dfn> insertion mode</h6>
- <p>Handle the token as follows:</p>
+ <p>Handle the token as follows:</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p><span title="append a character">Append the character</span> to
- the <span>current node</span>.</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p><span title="append a character">Append the character</span> to
+ the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is "head"</dt>
- <dd>
+ <dt>A start tag whose tag name is "head"</dt>
+ <dd>
- <p><span>Create an element for the token</span>.</p>
+ <p><span>Create an element for the token</span>.</p>
- <p>Set the <span><code title="">head</code> element
- pointer</span> to this new element node.</p>
+ <p>Set the <span><code title="">head</code> element
+ pointer</span> to this new element node.</p>
- <p>Append the new element to the <span>current node</span> and
- push it onto the <span>stack of open elements</span>.</p>
+ <p>Append the new element to the <span>current node</span> and
+ push it onto the <span>stack of open elements</span>.</p>
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: in head">in head</span>".</p>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: in head">in head</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag token whose tag name is one of: "base", "link",
- "meta", "script", "style", "title"</dt>
+ <dt>A start tag token whose tag name is one of: "base", "link",
+ "meta", "script", "style", "title"</dt>
- <dd>
+ <dd>
- <p>Act as if a start tag token with the tag name "head" and no
- attributes had been seen, then reprocess the current
- token.</p>
+ <p>Act as if a start tag token with the tag name "head" and no
+ attributes had been seen, then reprocess the current
+ token.</p>
- <p class="note">This will result in a <code>head</code>
- element being generated, and with the current token being
- reprocessed in the "<span title="insertion mode: in head">in
- head</span>" <span>insertion mode</span>.</p>
+ <p class="note">This will result in a <code>head</code>
+ element being generated, and with the current token being
+ reprocessed in the "<span title="insertion mode: in head">in
+ head</span>" <span>insertion mode</span>.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "head", "body", "html", "p", "br"</dt>
- <dd>
+ <dt>An end tag whose tag name is one of: "head", "body", "html", "p", "br"</dt>
+ <dd>
- <p>Act as if a start tag token with the tag name "head" and no
- attributes had been seen, then reprocess the current
- token.</p>
+ <p>Act as if a start tag token with the tag name "head" and no
+ attributes had been seen, then reprocess the current
+ token.</p>
- </dd>
+ </dd>
- <dt>Any other end tag</dt>
- <dd>
+ <dt>Any other end tag</dt>
+ <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
+ <p><span>Parse error</span>. Ignore the token.</p>
- <p class="big-issue">Do we really want to ignore end tags here?</p>
+ <p class="big-issue">Do we really want to ignore end tags here?</p>
- </dd>
+ </dd>
- <dt>A character token that is <em>not</em> one of U+0009 CHARACTER
- TABULATION, U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C
- FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),--> or U+0020 SPACE</dt>
- <dt>Any other start tag token</dt>
- <dd>
+ <dt>A character token that is <em>not</em> one of U+0009 CHARACTER
+ TABULATION, U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C
+ FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),--> or U+0020 SPACE</dt>
+ <dt>Any other start tag token</dt>
+ <dd>
- <p>Act as if a start tag token with the tag name "head" and no
- attributes had been seen, then reprocess the current
- token.</p>
+ <p>Act as if a start tag token with the tag name "head" and no
+ attributes had been seen, then reprocess the current
+ token.</p>
- <p class="note">This will result in an empty <code>head</code>
- element being generated, with the current token being
- reprocessed in the "<span title="insertion mode: after
- head">after head</span>" <span>insertion mode</span>.</p>
+ <p class="note">This will result in an empty <code>head</code>
+ element being generated, with the current token being
+ reprocessed in the "<span title="insertion mode: after
+ head">after head</span>" <span>insertion mode</span>.</p>
- </dd>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-inhead">The <dfn title="insertion mode: in head">in head</dfn> insertion mode</h6>
+ <h6 id="parsing-main-inhead">The <dfn title="insertion mode: in head">in head</dfn> insertion mode</h6>
- <p>Handle the token as follows.</p>
+ <p>Handle the token as follows.</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p><span title="append a character">Append the character</span> to
- the <span>current node</span>.</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p><span title="append a character">Append the character</span> to
+ the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is one of: "base", "link"</dt>
- <dd>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token.</p>
- </dd>
+ <dt>A start tag whose tag name is one of: "base", "link"</dt>
+ <dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "meta"</dt>
- <dd>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token.</p>
+ <dt>A start tag whose tag name is "meta"</dt>
+ <dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token.</p>
- <p id="meta-charset-during-parse">If the element has a <code
- title="attr-meta-charset">charset</code> attribute, and its
- value is a supported encoding, and the <span
- title="concept-encoding-confidence">confidence</span> is
- currently <i>tentative</i>, then <span>change the
- encoding</span> to the encoding given by the value of the
- <code title="attr-meta-charset">charset</code> attribute.</p>
+ <p id="meta-charset-during-parse">If the element has a <code
+ title="attr-meta-charset">charset</code> attribute, and its
+ value is a supported encoding, and the <span
+ title="concept-encoding-confidence">confidence</span> is
+ currently <i>tentative</i>, then <span>change the
+ encoding</span> to the encoding given by the value of the
+ <code title="attr-meta-charset">charset</code> attribute.</p>
- <p>Otherwise, if the element has a <code
- title="attr-meta-charset">content</code> attribute, and
- applying the <span>algorithm for extracting an encoding from a
- Content-Type</span> to its value returns a supported encoding
- <var title="">encoding</var>, and the <span
- title="concept-encoding-confidence">confidence</span> is
- currently <i>tentative</i>, then <span>change the
- encoding</span> to the encoding <var
- title="">encoding</var>.</p>
+ <p>Otherwise, if the element has a <code
+ title="attr-meta-charset">content</code> attribute, and
+ applying the <span>algorithm for extracting an encoding from a
+ Content-Type</span> to its value returns a supported encoding
+ <var title="">encoding</var>, and the <span
+ title="concept-encoding-confidence">confidence</span> is
+ currently <i>tentative</i>, then <span>change the
+ encoding</span> to the encoding <var
+ title="">encoding</var>.</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "title"</dt>
- <dd>
- <p>Follow the <span>generic RCDATA parsing algorithm</span>,
- with the <span><code>head</code> element pointer</span> as the
- <var title="">context node</var>, unless that's null, in which
- case use the <span>current node</span> (<span>fragment
- cose</span>).</p>
- </dd>
+ <dt>A start tag whose tag name is "title"</dt>
+ <dd>
+ <p>Follow the <span>generic RCDATA parsing algorithm</span>,
+ with the <span><code>head</code> element pointer</span> as the
+ <var title="">context node</var>, unless that's null, in which
+ case use the <span>current node</span> (<span>fragment
+ cose</span>).</p>
+ </dd>
- <dt>A start tag whose tag name is "noscript", if <span>scripting is enabled</span>:</dt>
- <dt>A start tag whose tag name is "style"</dt>
- <dd>
- <p>Follow the <span>generic CDATA parsing algorithm</span>,
- with the <span>current node</span> as the <var
- title="">context node</var>.</p>
- </dd>
+ <dt>A start tag whose tag name is "noscript", if <span>scripting is enabled</span>:</dt>
+ <dt>A start tag whose tag name is "style"</dt>
+ <dd>
+ <p>Follow the <span>generic CDATA parsing algorithm</span>,
+ with the <span>current node</span> as the <var
+ title="">context node</var>.</p>
+ </dd>
- <dt>A start tag whose tag name is "noscript", if <span>scripting is disabled</span>:</dt>
- <dd>
+ <dt>A start tag whose tag name is "noscript", if <span>scripting is disabled</span>:</dt>
+ <dd>
- <p><span title="insert an HTML element">Insert a
- <code>noscript</code> element</span> for the token.</p>
+ <p><span title="insert an HTML element">Insert a
+ <code>noscript</code> element</span> for the token.</p>
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: in head noscript">in head
- noscript</span>".</p>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: in head noscript">in head
+ noscript</span>".</p>
- </dd>
+ </dd>
- <dt id="scriptTag">A start tag whose tag name is "script"</dt>
- <dd>
+ <dt id="scriptTag">A start tag whose tag name is "script"</dt>
+ <dd>
- <p><span>Create an element for the token</span>.</p>
+ <p><span>Create an element for the token</span>.</p>
- <p>Mark the element as being
- <span>"parser-inserted"</span>. This ensures that, if the
- script is external, any <code
- title="dom-document-write-HTML">document.write()</code> calls
- in the script will execute in-line, instead of blowing the
- document away, as would happen in most other cases.</p>
+ <p>Mark the element as being
+ <span>"parser-inserted"</span>. This ensures that, if the
+ script is external, any <code
+ title="dom-document-write-HTML">document.write()</code> calls
+ in the script will execute in-line, instead of blowing the
+ document away, as would happen in most other cases.</p>
- <p>Switch the tokeniser's <span>content model flag</span> to
- the CDATA state.</p>
+ <p>Switch the tokeniser's <span>content model flag</span> to
+ the CDATA state.</p>
- <p>Then, collect all the character tokens that the tokeniser
- returns until it returns a token that is not a character
- token, or until it stops tokenising.</p>
+ <p>Then, collect all the character tokens that the tokeniser
+ returns until it returns a token that is not a character
+ token, or until it stops tokenising.</p>
- <p>If this process resulted in a collection of character
- tokens, append a single <code>Text</code> node to the
- <code>script</code> element node whose contents is the
- concatenation of all those tokens' characters.</p>
+ <p>If this process resulted in a collection of character
+ tokens, append a single <code>Text</code> node to the
+ <code>script</code> element node whose contents is the
+ concatenation of all those tokens' characters.</p>
- <p>The tokeniser's <span>content model flag</span> will have
- switched back to the PCDATA state.</p>
+ <p>The tokeniser's <span>content model flag</span> will have
+ switched back to the PCDATA state.</p>
- <p>If the next token is not an end tag token with the tag name
- "script", then this is a <span>parse error</span>; mark the
- <code>script</code> element as <span>"already
- executed"</span>. Otherwise, the token is the
- <code>script</code> element's end tag, so ignore it.</p>
+ <p>If the next token is not an end tag token with the tag name
+ "script", then this is a <span>parse error</span>; mark the
+ <code>script</code> element as <span>"already
+ executed"</span>. Otherwise, the token is the
+ <code>script</code> element's end tag, so ignore it.</p>
- <p>If the parser was originally created for the <span>HTML
- fragment parsing algorithm</span>, then mark the
- <code>script</code> element as <span>"already
- executed"</span>, and skip the rest of the processing
- described for this token (including the part below where
- "<span title="the script that will execute as soon as the
- parser resumes">scripts that will execute as soon as the
- parser resumes</span>" are executed). (<span>fragment
- case</span>)</p>
+ <p>If the parser was originally created for the <span>HTML
+ fragment parsing algorithm</span>, then mark the
+ <code>script</code> element as <span>"already
+ executed"</span>, and skip the rest of the processing
+ described for this token (including the part below where
+ "<span title="the script that will execute as soon as the
+ parser resumes">scripts that will execute as soon as the
+ parser resumes</span>" are executed). (<span>fragment
+ case</span>)</p>
- <p class="note">Marking the <code>script</code> element as
- "already executed" prevents it from executing when it is
- inserted into the document a few paragraphs below. Thus,
- scripts missing their end tags and scripts that were inserted
- using <code title="dom-innerHTML-HTML">innerHTML</code> aren't
- executed.</p>
+ <p class="note">Marking the <code>script</code> element as
+ "already executed" prevents it from executing when it is
+ inserted into the document a few paragraphs below. Thus,
+ scripts missing their end tags and scripts that were inserted
+ using <code title="dom-innerHTML-HTML">innerHTML</code> aren't
+ executed.</p>
- <p>Let the <var title="">old insertion point</var> have the
- same value as the current <span>insertion point</span>. Let
- the <span>insertion point</span> be just before the <span>next
- input character</span>.</p>
+ <p>Let the <var title="">old insertion point</var> have the
+ same value as the current <span>insertion point</span>. Let
+ the <span>insertion point</span> be just before the <span>next
+ input character</span>.</p>
- <p>Append the new element to the <span>current node</span>.
- <span title="running a script">Special processing occurs when
- a <code>script</code> element is inserted into a
- document</span> that might cause some script to execute, which
- might cause <span title="dom-document-write-HTML">new
- characters to be inserted into the tokeniser</span>.</p>
+ <p>Append the new element to the <span>current node</span>.
+ <span title="running a script">Special processing occurs when
+ a <code>script</code> element is inserted into a
+ document</span> that might cause some script to execute, which
+ might cause <span title="dom-document-write-HTML">new
+ characters to be inserted into the tokeniser</span>.</p>
- <p>Let the <span>insertion point</span> have the value of the
- <var title="">old insertion point</var>. (In other words,
- restore the <span>insertion point</span> to the value it had
- before the previous paragraph. This value might be the
- "undefined" value.)</p>
+ <p>Let the <span>insertion point</span> have the value of the
+ <var title="">old insertion point</var>. (In other words,
+ restore the <span>insertion point</span> to the value it had
+ before the previous paragraph. This value might be the
+ "undefined" value.)</p>
- <p id="scriptTagParserResumes">At this stage, if there is
- <span title="the script that will execute as soon as the
- parser resumes">a script that will execute as soon as the
- parser resumes</span>, then:</p>
+ <p id="scriptTagParserResumes">At this stage, if there is
+ <span title="the script that will execute as soon as the
+ parser resumes">a script that will execute as soon as the
+ parser resumes</span>, then:</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>If the tree construction stage is <a
- href="#nestedParsing">being called reentrantly</a>, say from
- a call to <code
- title="dom-document-write-HTML">document.write()</code>:</dt>
+ <dt>If the tree construction stage is <a
+ href="#nestedParsing">being called reentrantly</a>, say from
+ a call to <code
+ title="dom-document-write-HTML">document.write()</code>:</dt>
- <dd><p>Abort the processing of any nested invokations of the
- tokeniser, yielding control back to the caller. (Tokenisation
- will resume when the caller returns to the "outer" tree
- construction stage.)</p></dd>
+ <dd><p>Abort the processing of any nested invokations of the
+ tokeniser, yielding control back to the caller. (Tokenisation
+ will resume when the caller returns to the "outer" tree
+ construction stage.)</p></dd>
- <dt>Otherwise:</dt>
+ <dt>Otherwise:</dt>
- <dd>
+ <dd>
- <p>Follow these steps:</p>
+ <p>Follow these steps:</p>
- <ol>
+ <ol>
- <li><p>Let <var title="">the script</var> be <span>the
- script that will execute as soon as the parser
- resumes</span>. There is no longer <span title="the script
- that will execute as soon as the parser resumes">a script
- that will execute as soon as the parser
- resumes</span>.</p></li>
+ <li><p>Let <var title="">the script</var> be <span>the
+ script that will execute as soon as the parser
+ resumes</span>. There is no longer <span title="the script
+ that will execute as soon as the parser resumes">a script
+ that will execute as soon as the parser
+ resumes</span>.</p></li>
- <li><p><span>Pause</span> until the script has <span>completed
- loading</span><!-- XXX xref -->.</p></li>
+ <li><p><span>Pause</span> until the script has <span>completed
+ loading</span><!-- XXX xref -->.</p></li>
- <li><p>Let the <span>insertion point</span> be just before the
- <span>next input character</span>.</p></li>
+ <li><p>Let the <span>insertion point</span> be just before the
+ <span>next input character</span>.</p></li>
- <li><p><span title="executing a script block">Execute the
- script</span>.</p></li>
+ <li><p><span title="executing a script block">Execute the
+ script</span>.</p></li>
- <li><p>Let the <span>insertion point</span> be undefined
- again.</p></li>
+ <li><p>Let the <span>insertion point</span> be undefined
+ again.</p></li>
- <li><p>If there is once again <span title="the script that
- will execute as soon as the parser resumes">a script that
- will execute as soon as the parser resumes</span>, then
- repeat these steps from step 1.</p></li>
+ <li><p>If there is once again <span title="the script that
+ will execute as soon as the parser resumes">a script that
+ will execute as soon as the parser resumes</span>, then
+ repeat these steps from step 1.</p></li>
- </ol>
+ </ol>
- </dd>
+ </dd>
- </dl>
+ </dl>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "head"</dt>
- <dd>
+ <dt>An end tag whose tag name is "head"</dt>
+ <dd>
- <p>Pop the <span>current node</span> (which will be the
- <code>head</code> element) off the <span>stack of open
- elements</span>.</p>
+ <p>Pop the <span>current node</span> (which will be the
+ <code>head</code> element) off the <span>stack of open
+ elements</span>.</p>
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: after head">after head</span>".</p>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: after head">after head</span>".</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "body", "html", "p", "br"</dt>
- <dd>
- <p>Act as described in the "anything else" entry below.</p>
- </dd>
+ <dt>An end tag whose tag name is one of: "body", "html", "p", "br"</dt>
+ <dd>
+ <p>Act as described in the "anything else" entry below.</p>
+ </dd>
- <dt>A start tag whose tag name is "head"</dt>
- <dt>Any other end tag</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A start tag whose tag name is "head"</dt>
+ <dt>Any other end tag</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
+ <dt>Anything else</dt>
+ <dd>
- <p>Act as if an end tag token with the tag name "head" had
- been seen, and reprocess the current token.</p>
+ <p>Act as if an end tag token with the tag name "head" had
+ been seen, and reprocess the current token.</p>
- <p class="big-issue">In certain UAs, <a
- href="https://bugzilla.mozilla.org/attachment.cgi?id=180157&action=view">some
- elements</a> don't trigger the "in body" mode straight away,
- but instead get put into the head. Do we want to copy
- that?</p>
+ <p class="big-issue">In certain UAs, <a
+ href="https://bugzilla.mozilla.org/attachment.cgi?id=180157&action=view">some
+ elements</a> don't trigger the "in body" mode straight away,
+ but instead get put into the head. Do we want to copy
+ that?</p>
- </dd>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-inheadnoscript">The <dfn title="insertion mode: in head noscript">in head noscript</dfn> insertion mode</h6>
+ <h6 id="parsing-main-inheadnoscript">The <dfn title="insertion mode: in head noscript">in head noscript</dfn> insertion mode</h6>
- <p>Handle the token as follows.</p>
+ <p>Handle the token as follows.</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>An end tag whose tag name is "noscript"</dt>
- <dd>
+ <dt>An end tag whose tag name is "noscript"</dt>
+ <dd>
- <p>Pop the <span>current node</span> (which will be a
- <code>noscript</code> element) from the <span>stack of open
- elements</span>; the new <span>current node</span> will be a
- <code>head</code> element.</p>
+ <p>Pop the <span>current node</span> (which will be a
+ <code>noscript</code> element) from the <span>stack of open
+ elements</span>; the new <span>current node</span> will be a
+ <code>head</code> element.</p>
- <p>Switch the <span>insertion mode</span> to "<span
- title="insertion mode: in head">in head</span>".</p>
+ <p>Switch the <span>insertion mode</span> to "<span
+ title="insertion mode: in head">in head</span>".</p>
- </dd>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dt>A comment token</dt>
- <dt>A start tag whose tag name is one of: "link", "meta", "style"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in head">in
- head</span>".</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dt>A comment token</dt>
+ <dt>A start tag whose tag name is one of: "link", "meta", "style"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in head">in
+ head</span>".</p>
+ </dd>
- <dt>An end tag whose tag name is one of: "p", "br"</dt>
- <dd>
- <p>Act as described in the "anything else" entry below.</p>
- </dd>
+ <dt>An end tag whose tag name is one of: "p", "br"</dt>
+ <dd>
+ <p>Act as described in the "anything else" entry below.</p>
+ </dd>
- <dt>A start tag whose tag name is one of: "head", "noscript"</dt>
- <dt>Any other end tag</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A start tag whose tag name is one of: "head", "noscript"</dt>
+ <dt>Any other end tag</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p><span>Parse error</span>. Act as if an end tag with the tag
- name "noscript" had been seen and reprocess the current
- token.</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p><span>Parse error</span>. Act as if an end tag with the tag
+ name "noscript" had been seen and reprocess the current
+ token.</p>
+ </dd>
- </dl>
+ </dl>
- <h6>The <dfn title="insertion mode: after head">after head</dfn> insertion mode</h6>
+ <h6>The <dfn title="insertion mode: after head">after head</dfn> insertion mode</h6>
- <p>Handle the token as follows:</p>
+ <p>Handle the token as follows:</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p><span title="append a character">Append the character</span> to
- the <span>current node</span>.</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p><span title="append a character">Append the character</span> to
+ the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is "body"</dt>
- <dd>
+ <dt>A start tag whose tag name is "body"</dt>
+ <dd>
- <p><span title="insert an HTML element">Insert a
- <code>body</code> element</span> for the token.</p>
+ <p><span title="insert an HTML element">Insert a
+ <code>body</code> element</span> for the token.</p>
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: in body">in body</span>".</p>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: in body">in body</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "frameset"</dt>
- <dd>
+ <dt>A start tag whose tag name is "frameset"</dt>
+ <dd>
- <p><span title="insert an HTML element">Insert a
- <code>frameset</code> element</span> for the token.</p>
+ <p><span title="insert an HTML element">Insert a
+ <code>frameset</code> element</span> for the token.</p>
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: in frameset">in frameset</span>".</p>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: in frameset">in frameset</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag token whose tag name is one of: "base", "link",
- "meta", "script", "style", "title"</dt>
- <dd>
+ <dt>A start tag token whose tag name is one of: "base", "link",
+ "meta", "script", "style", "title"</dt>
+ <dd>
- <p><span>Parse error</span>.</p>
+ <p><span>Parse error</span>.</p>
- <p>Push the node pointed to by the <span><code
- title="">head</code> element pointer</span> onto the
- <span>stack of open elements</span>.</p>
+ <p>Push the node pointed to by the <span><code
+ title="">head</code> element pointer</span> onto the
+ <span>stack of open elements</span>.</p>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in head">in
- head</span>".</p>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in head">in
+ head</span>".</p>
- <p>Pop the <span>current node</span> (which will be the node
- pointed to by the <span><code title="">head</code> element
- pointer</span>) off the <span>stack of open
- elements</span>.</p>
+ <p>Pop the <span>current node</span> (which will be the node
+ pointed to by the <span><code title="">head</code> element
+ pointer</span>) off the <span>stack of open
+ elements</span>.</p>
- </dd>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p>Act as if a start tag token with the tag name "body" and no
- attributes had been seen, and then reprocess the current
- token.</p>
- </dd>
-
- </dl>
+ <dt>Anything else</dt>
+ <dd>
+ <p>Act as if a start tag token with the tag name "body" and no
+ attributes had been seen, and then reprocess the current
+ token.</p>
+ </dd>
+ </dl>
- <h6 id="parsing-main-inbody">The <dfn title="insertion mode: in body">in body</dfn> insertion mode</h6>
- <p>Handle the token as follows:</p>
+ <h6 id="parsing-main-inbody">The <dfn title="insertion mode: in body">in body</dfn> insertion mode</h6>
- <dl class="switch">
+ <p>Handle the token as follows:</p>
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dl class="switch">
- <dt>A character token</dt>
- <dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <dt>A character token</dt>
+ <dd>
- <p><span title="append a character">Append the token's
- character</span> to the <span>current node</span>.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- </dd>
+ <p><span title="append a character">Append the token's
+ character</span> to the <span>current node</span>.</p>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>If this start tag token was not the first start tag token, then
- it is a <span>parse error</span>.</p>
- <p>For each attribute on the token, check to see if the attribute
- is already present on the top element of the <span>stack of open
- elements</span>. If it is not, add the attribute and its
- corresponding value to that element.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag token whose tag name is one of: "base", "link",
- "meta", "script", "style"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in head">in head</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>If this start tag token was not the first start tag token, then
+ it is a <span>parse error</span>.</p>
+ <p>For each attribute on the token, check to see if the attribute
+ is already present on the top element of the <span>stack of open
+ elements</span>. If it is not, add the attribute and its
+ corresponding value to that element.</p>
+ </dd>
- <dt>A start tag whose tag name is "title"</dt>
- <dd>
- <p><span>Parse error</span>. Process the token as if the
- <span>insertion mode</span> had been "<span title="insertion
- mode: in head">in head</span>".</p>
- </dd>
+ <dt>A start tag token whose tag name is one of: "base", "link",
+ "meta", "script", "style"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in head">in head</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is "body"</dt>
- <dd>
+ <dt>A start tag whose tag name is "title"</dt>
+ <dd>
+ <p><span>Parse error</span>. Process the token as if the
+ <span>insertion mode</span> had been "<span title="insertion
+ mode: in head">in head</span>".</p>
+ </dd>
- <p><span>Parse error</span>.</p>
+ <dt>A start tag whose tag name is "body"</dt>
+ <dd>
- <p>If the second element on the <span>stack of open
- elements</span> is not a <code>body</code> element, or, if the
- <span>stack of open elements</span> has only one node on it,
- then ignore the token. (<span>fragment case</span>)</p>
+ <p><span>Parse error</span>.</p>
- <p>Otherwise, for each attribute on the token, check to see if
- the attribute is already present on the <code>body</code>
- element (the second element) on the <span>stack of open
- elements</span>. If it is not, add the attribute and its
- corresponding value to that element.</p>
+ <p>If the second element on the <span>stack of open
+ elements</span> is not a <code>body</code> element, or, if the
+ <span>stack of open elements</span> has only one node on it,
+ then ignore the token. (<span>fragment case</span>)</p>
- </dd>
+ <p>Otherwise, for each attribute on the token, check to see if
+ the attribute is already present on the <code>body</code>
+ element (the second element) on the <span>stack of open
+ elements</span>. If it is not, add the attribute and its
+ corresponding value to that element.</p>
- <dt>An end tag whose tag name is "body"</dt>
- <dd>
+ </dd>
- <p>If the second element in the <span>stack of open
- elements</span> is not a <code>body</code> element, this is a
- <span>parse error</span>. Ignore the token. (<span>fragment
- case</span>)</p>
+ <dt>An end tag whose tag name is "body"</dt>
+ <dd>
- <p>Otherwise, if there is a node in the <span>stack of open
- elements</span> that is not either a <code>dd</code> element,
- a <code>dt</code> element, an <code>li</code> element, a
- <code>p</code> element, a <code>tbody</code> element, a
- <code>td</code> element, a <code>tfoot</code> element, a
- <code>th</code> element, a <code>thead</code> element, a
- <code>tr</code> element, the <code>body</code> element, or the
- <code>html</code> element, then this is a <span>parse
- error</span>.</li>
+ <p>If the second element in the <span>stack of open
+ elements</span> is not a <code>body</code> element, this is a
+ <span>parse error</span>. Ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: after body">after body</span>".</p>
+ <p>Otherwise, if there is a node in the <span>stack of open
+ elements</span> that is not either a <code>dd</code> element,
+ a <code>dt</code> element, an <code>li</code> element, a
+ <code>p</code> element, a <code>tbody</code> element, a
+ <code>td</code> element, a <code>tfoot</code> element, a
+ <code>th</code> element, a <code>thead</code> element, a
+ <code>tr</code> element, the <code>body</code> element, or the
+ <code>html</code> element, then this is a <span>parse
+ error</span>.</li>
- </dd>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: after body">after body</span>".</p>
- <dt>An end tag whose tag name is "html"</dt>
- <dd>
+ </dd>
- <p>Act as if an end tag with tag name "body" had been seen,
- then, if that token wasn't ignored, reprocess the current
- token.</p>
+ <dt>An end tag whose tag name is "html"</dt>
+ <dd>
- <p class="note">The fake end tag token here can only be
- ignored in the <span>fragment case</span>.</p>
+ <p>Act as if an end tag with tag name "body" had been seen,
+ then, if that token wasn't ignored, reprocess the current
+ token.</p>
- </dd>
+ <p class="note">The fake end tag token here can only be
+ ignored in the <span>fragment case</span>.</p>
- <dt>A start tag whose tag name is one of: "address",
- "blockquote", "center", "dir", "div", "dl", "fieldset",
- "listing", "menu", "ol", "p", "ul"</dt>
- <dd>
+ </dd>
- <p class="big-issue">This doesn't match browsers.</p>
- <!-- XXX <p><i><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cp%3E%3C%2Fp%3E%3C%2Fi%3E%3C%2Fp%3E -->
- <!-- XXX <p><i><div><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cdiv%3E%3Cp%3E%3C%2Fp%3E%3C%2Fdiv%3E%3C%2Fi%3E%3C%2Fp%3E -->
+ <dt>A start tag whose tag name is one of: "address",
+ "blockquote", "center", "dir", "div", "dl", "fieldset",
+ "listing", "menu", "ol", "p", "ul"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p>
+ <p class="big-issue">This doesn't match browsers.</p>
+ <!-- XXX <p><i><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cp%3E%3C%2Fp%3E%3C%2Fi%3E%3C%2Fp%3E -->
+ <!-- XXX <p><i><div><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cdiv%3E%3Cp%3E%3C%2Fp%3E%3C%2Fdiv%3E%3C%2Fi%3E%3C%2Fp%3E -->
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p>
- </dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token.</p>
- <dt>A start tag whose tag name is "pre"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p>
+ <dt>A start tag whose tag name is "pre"</dt>
+ <dd>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p>
- <p>If the next token is a U+000A LINE FEED (LF) character
- token, then ignore that token and move on to the next
- one. (Newlines at the start of <code>pre</code> blocks are
- ignored as an authoring convenience.)</p>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token.</p>
- </dd>
+ <p>If the next token is a U+000A LINE FEED (LF) character
+ token, then ignore that token and move on to the next
+ one. (Newlines at the start of <code>pre</code> blocks are
+ ignored as an authoring convenience.)</p>
- <dt>A start tag whose tag name is "form"</dt>
- <dd>
+ </dd>
- <p>If the <span><code title="form">form</code> element
- pointer</span> is not null, ignore the token with a
- <span>parse error</span>.</p>
+ <dt>A start tag whose tag name is "form"</dt>
+ <dd>
- <p>Otherwise:</p>
+ <p>If the <span><code title="form">form</code> element
+ pointer</span> is not null, ignore the token with a
+ <span>parse error</span>.</p>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p>
+ <p>Otherwise:</p>
- <p><span title="insert an html Element">Insert an HTML
- element</span> for the token, and set the <code
- title="form">form</code> element pointer to point to the
- element created.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p>
- </dd>
+ <p><span title="insert an html Element">Insert an HTML
+ element</span> for the token, and set the <code
+ title="form">form</code> element pointer to point to the
+ element created.</p>
- <dt>A start tag whose tag name is "li"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p>
+ <dt>A start tag whose tag name is "li"</dt>
+ <dd>
- <p>Run the following algorithm:</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p>
- <ol>
+ <p>Run the following algorithm:</p>
- <li><p>Initialise <var title="">node</var> to be the <span>current
- node</span> (the bottommost node of the stack).</p></li>
+ <ol>
- <li><p>If <var title="">node</var> is an <code>li</code>
- element, then pop all the nodes from the <span>current
- node</span> up to <var title="">node</var>, including <var
- title="">node</var>, then stop this algorithm. If more than
- one node is popped, then this is a <span>parse
- error</span>.</p></li>
+ <li><p>Initialise <var title="">node</var> to be the <span>current
+ node</span> (the bottommost node of the stack).</p></li>
- <li><p>If <var title="">node</var> is not in the
- <span>formatting</span> category, and is not in the
- <span>phrasing</span> category, and is not an
- <code>address</code> or <code>div</code> element, then stop
- this algorithm.</p></li> <!-- an element <foo> is in this
- list if the following markup:
+ <li><p>If <var title="">node</var> is an <code>li</code>
+ element, then pop all the nodes from the <span>current
+ node</span> up to <var title="">node</var>, including <var
+ title="">node</var>, then stop this algorithm. If more than
+ one node is popped, then this is a <span>parse
+ error</span>.</p></li>
- <!DOCTYPE html><body><ol><li><foo><li>
+ <li><p>If <var title="">node</var> is not in the
+ <span>formatting</span> category, and is not in the
+ <span>phrasing</span> category, and is not an
+ <code>address</code> or <code>div</code> element, then stop
+ this algorithm.</p></li> <!-- an element <foo> is in this
+ list if the following markup:
- ...results in the second <li> not being (in any way) a
- descendant of the first <li>, or if <foo> is a formatting
- element that gets reopened later. -->
+ <!DOCTYPE html><body><ol><li><foo><li>
- <li><p>Otherwise, set <var title="">node</var> to the previous entry
- in the <span>stack of open elements</span> and return to step
- 2.</p></li>
+ ...results in the second <li> not being (in any way) a
+ descendant of the first <li>, or if <foo> is a formatting
+ element that gets reopened later. -->
- </ol>
+ <li><p>Otherwise, set <var title="">node</var> to the previous entry
+ in the <span>stack of open elements</span> and return to step
+ 2.</p></li>
- <p>Finally, <span title="insert an html element">insert an
- <code>li</code> element</span>.</p>
+ </ol>
- </dd>
+ <p>Finally, <span title="insert an html element">insert an
+ <code>li</code> element</span>.</p>
- <dt>A start tag whose tag name is one of: "dd", "dt"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p>
+ <dt>A start tag whose tag name is one of: "dd", "dt"</dt>
+ <dd>
- <p>Run the following algorithm:</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p>
- <ol>
+ <p>Run the following algorithm:</p>
- <li><p>Initialise <var title="">node</var> to be the <span>current
- node</span> (the bottommost node of the stack).</p></li>
+ <ol>
- <li><p>If <var title="">node</var> is a <code>dd</code> or
- <code>dt</code> element, then pop all the nodes from the
- <span>current node</span> up to <var title="">node</var>,
- including <var title="">node</var>, then stop this algorithm.
- If more than one node is popped, then this is a <span>parse
- error</span>.</p></li>
+ <li><p>Initialise <var title="">node</var> to be the <span>current
+ node</span> (the bottommost node of the stack).</p></li>
- <li><p>If <var title="">node</var> is not in the
- <span>formatting</span> category, and is not in the
- <span>phrasing</span> category, and is not an
- <code>address</code> or <code>div</code> element, then stop
- this algorithm.</p></li> <!-- an element <foo> is in this
- list if the following markup:
+ <li><p>If <var title="">node</var> is a <code>dd</code> or
+ <code>dt</code> element, then pop all the nodes from the
+ <span>current node</span> up to <var title="">node</var>,
+ including <var title="">node</var>, then stop this algorithm.
+ If more than one node is popped, then this is a <span>parse
+ error</span>.</p></li>
- <!DOCTYPE html><body><ol><dt><foo><dt>
+ <li><p>If <var title="">node</var> is not in the
+ <span>formatting</span> category, and is not in the
+ <span>phrasing</span> category, and is not an
+ <code>address</code> or <code>div</code> element, then stop
+ this algorithm.</p></li> <!-- an element <foo> is in this
+ list if the following markup:
- ...results in the second <li> not being (in any way) a
- descendant of the first <li>, or if <foo> is a formatting
- element that gets reopened later. -->
+ <!DOCTYPE html><body><ol><dt><foo><dt>
- <li><p>Otherwise, set <var title="">node</var> to the previous entry
- in the <span>stack of open elements</span> and return to step
- 2.</p></li>
+ ...results in the second <li> not being (in any way) a
+ descendant of the first <li>, or if <foo> is a formatting
+ element that gets reopened later. -->
- </ol>
+ <li><p>Otherwise, set <var title="">node</var> to the previous entry
+ in the <span>stack of open elements</span> and return to step
+ 2.</p></li>
- <p>Finally, <span title="insert an html element">insert an
- HTML element</span> with the same tag name as the token's.</p>
+ </ol>
- </dd>
+ <p>Finally, <span title="insert an html element">insert an
+ HTML element</span> with the same tag name as the token's.</p>
- <dt>A start tag whose tag name is "plaintext"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p>
+ <dt>A start tag whose tag name is "plaintext"</dt>
+ <dd>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p>
- <p>Switch the <span>content model flag</span> to the PLAINTEXT
- state.</p>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token.</p>
- <p class="note">Once a start tag with the tag name "plaintext"
- has been seen, that will be the last token ever seen other
- than character tokens (and the end-of-file token), because
- there is no way to switch the <span>content model flag</span>
- out of the PLAINTEXT state.</p>
+ <p>Switch the <span>content model flag</span> to the PLAINTEXT
+ state.</p>
- </dd>
+ <p class="note">Once a start tag with the tag name "plaintext"
+ has been seen, that will be the last token ever seen other
+ than character tokens (and the end-of-file token), because
+ there is no way to switch the <span>content model flag</span>
+ out of the PLAINTEXT state.</p>
- <dt>An end tag whose tag name is one of: "address",
- "blockquote", "center", "dir", "div", "dl", "fieldset",
- "listing", "menu", "ol", "pre", "ul"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span>has an
- element in scope</span> with the same tag name as that of the
- token, then <span>generate implied end tags</span>.</p>
+ <dt>An end tag whose tag name is one of: "address",
+ "blockquote", "center", "dir", "div", "dl", "fieldset",
+ "listing", "menu", "ol", "pre", "ul"</dt>
+ <dd>
- <p>Now, if the <span>current node</span> is not an element
- with the same tag name as that of the token, then this is a
- <span>parse error</span>.</p>
+ <p>If the <span>stack of open elements</span> <span>has an
+ element in scope</span> with the same tag name as that of the
+ token, then <span>generate implied end tags</span>.</p>
- <p>If the <span>stack of open elements</span> <span>has an
- element in scope</span> with the same tag name as that of the
- token, then pop elements from this stack until an element with
- that tag name has been popped from the stack.</p>
+ <p>Now, if the <span>current node</span> is not an element
+ with the same tag name as that of the token, then this is a
+ <span>parse error</span>.</p>
- <!-- XXX quirk (except for in certain cases?):
- <p>Otherwise, act as if a start tag with the tag name given in
- the token had been seen, then reprocess the current token.</p>
- -->
+ <p>If the <span>stack of open elements</span> <span>has an
+ element in scope</span> with the same tag name as that of the
+ token, then pop elements from this stack until an element with
+ that tag name has been popped from the stack.</p>
- </dd>
+ <!-- XXX quirk (except for in certain cases?):
+ <p>Otherwise, act as if a start tag with the tag name given in
+ the token had been seen, then reprocess the current token.</p>
+ -->
- <dt>An end tag whose tag name is "form"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span>has an
- element in scope</span> with the same tag name as that of the
- token, then <span>generate implied end tags</span>.</p>
+ <dt>An end tag whose tag name is "form"</dt>
+ <dd>
- <p>Now, if the <span>current node</span> is not an element
- with the same tag name as that of the token, then this is a
- <span>parse error</span>.</p>
+ <p>If the <span>stack of open elements</span> <span>has an
+ element in scope</span> with the same tag name as that of the
+ token, then <span>generate implied end tags</span>.</p>
- <p>Otherwise, if the <span>current node</span> is an element
- with the same tag name as that of the token pop that element
- from the stack.</p>
+ <p>Now, if the <span>current node</span> is not an element
+ with the same tag name as that of the token, then this is a
+ <span>parse error</span>.</p>
- <p>In any case, set the <span><code title="">form</code>
- element pointer</span> to null.</p>
+ <p>Otherwise, if the <span>current node</span> is an element
+ with the same tag name as that of the token pop that element
+ from the stack.</p>
- </dd>
+ <p>In any case, set the <span><code title="">form</code>
+ element pointer</span> to null.</p>
- <dt>An end tag whose tag name is "p"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then <span>generate implied end tags</span>,
- except for <code>p</code> elements.</p>
+ <dt>An end tag whose tag name is "p"</dt>
+ <dd>
- <p>If the <span>current node</span> is not a <code>p</code>
- element, then this is a <span>parse error</span>.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then <span>generate implied end tags</span>,
+ except for <code>p</code> elements.</p>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then pop elements from this stack until the
- stack no longer <span title="has an element in scope">has a
- <code>p</code> element in scope</span>.</p>
+ <p>If the <span>current node</span> is not a <code>p</code>
+ element, then this is a <span>parse error</span>.</p>
- <p>Otherwise, act as if a start tag with the tag name
- <code>p</code> had been seen, then reprocess the current
- token.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then pop elements from this stack until the
+ stack no longer <span title="has an element in scope">has a
+ <code>p</code> element in scope</span>.</p>
- </dd>
+ <p>Otherwise, act as if a start tag with the tag name
+ <code>p</code> had been seen, then reprocess the current
+ token.</p>
- <dt>An end tag whose tag name is one of: "dd", "dt", "li"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span>has an
- element in scope</span> whose tag name matches the tag name of
- the token, then <span>generate implied end tags</span>, except
- for elements with the same tag name as the token.</p>
+ <dt>An end tag whose tag name is one of: "dd", "dt", "li"</dt>
+ <dd>
- <p>If the <span>current node</span> is not an element with the
- same tag name as the token, then this is a <span>parse
- error</span>.</p>
+ <p>If the <span>stack of open elements</span> <span>has an
+ element in scope</span> whose tag name matches the tag name of
+ the token, then <span>generate implied end tags</span>, except
+ for elements with the same tag name as the token.</p>
- <p>If the <span>stack of open elements</span> <span>has an
- element in scope</span> whose tag name matches the tag name of
- the token, then pop elements from this stack until an element
- with that tag name has been popped from the stack.</p>
+ <p>If the <span>current node</span> is not an element with the
+ same tag name as the token, then this is a <span>parse
+ error</span>.</p>
- </dd>
+ <p>If the <span>stack of open elements</span> <span>has an
+ element in scope</span> whose tag name matches the tag name of
+ the token, then pop elements from this stack until an element
+ with that tag name has been popped from the stack.</p>
- <dt>A start tag whose tag name is one of: "h1", "h2", "h3",
- "h4", "h5", "h6"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p>
+ <dt>A start tag whose tag name is one of: "h1", "h2", "h3",
+ "h4", "h5", "h6"</dt>
+ <dd>
- <!-- Removed for compatibility with IE7, though all other
- browsers do it this way. If you do put this back, make
- sure to handle <h1><a><h2>, as in Webkit bug 12646.
- http://bugs.webkit.org/show_bug.cgi?id=12646
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has in scope</span> an element whose tag
- name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
- this is a <span>parse error</span>; pop elements from the
- stack until an element with one of those tag names has been
- popped from the stack.</p>
- -->
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token.</p>
+ <!-- Removed for compatibility with IE7, though all other
+ browsers do it this way. If you do put this back, make
+ sure to handle <h1><a><h2>, as in Webkit bug 12646.
+ http://bugs.webkit.org/show_bug.cgi?id=12646
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has in scope</span> an element whose tag
+ name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
+ this is a <span>parse error</span>; pop elements from the
+ stack until an element with one of those tag names has been
+ popped from the stack.</p>
+ -->
- </dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token.</p>
- <dt>An end tag whose tag name is one of: "h1", "h2", "h3",
- "h4", "h5", "h6"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has in scope</span> an element whose tag
- name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
- <span>generate implied end tags</span>.</p>
+ <dt>An end tag whose tag name is one of: "h1", "h2", "h3",
+ "h4", "h5", "h6"</dt>
+ <dd>
- <p>Now, if the <span>current node</span> is not an element
- with the same tag name as that of the token, then this is a
- <span>parse error</span>.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has in scope</span> an element whose tag
+ name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
+ <span>generate implied end tags</span>.</p>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has in scope</span> an element whose tag
- name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then pop
- elements from the stack until an element with one of those tag
- names has been popped from the stack.</p>
+ <p>Now, if the <span>current node</span> is not an element
+ with the same tag name as that of the token, then this is a
+ <span>parse error</span>.</p>
- <!-- XXX quirk:
- <p>Otherwise, act as if a start tag with the tag name given in
- the token had been seen, then reprocess the current token.</p>
- -->
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has in scope</span> an element whose tag
+ name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then pop
+ elements from the stack until an element with one of those tag
+ names has been popped from the stack.</p>
- </dd>
+ <!-- XXX quirk:
+ <p>Otherwise, act as if a start tag with the tag name given in
+ the token had been seen, then reprocess the current token.</p>
+ -->
- <!-- ADOPTION AGENCY ELEMENTS
- Mozilla-only: bdo blink del ins sub sup q
- Safari-only: code dfn kbd nobr samp var wbr
- Both: a b big em font i s small strike strong tt u -->
+ </dd>
- <dt>A start tag whose tag name is "a"</dt>
- <dd>
+ <!-- ADOPTION AGENCY ELEMENTS
+ Mozilla-only: bdo blink del ins sub sup q
+ Safari-only: code dfn kbd nobr samp var wbr
+ Both: a b big em font i s small strike strong tt u -->
- <p>If the <span>list of active formatting elements</span>
- contains an element whose tag name is "a" between the end of
- the list and the last marker on the list (or the start of the
- list if there is no marker on the list), then this is a
- <span>parse error</span>; act as if an end tag with the tag
- name "a" had been seen, then remove that element from the
- <span>list of active formatting elements</span> and the
- <span>stack of open elements</span> if the end tag didn't
- already remove it (it might not have if the element is not
- <span title="has an element in table scope">in table
- scope</span>).</p>
+ <dt>A start tag whose tag name is "a"</dt>
+ <dd>
- <p class="example">In the non-conforming stream
- <code><a href="a">a<table><a href="b">b</table>x</code>,
- the first <code>a</code> element would be closed upon seeing
- the second one, and the "x" character would be inside a link
- to "b", not to "a". This is despite the fact that the outer
- <code>a</code> element is not in table scope (meaning that a
- regular <code></a></code> end tag at the start of the table
- wouldn't close the outer <code>a</code> element).</p>
+ <p>If the <span>list of active formatting elements</span>
+ contains an element whose tag name is "a" between the end of
+ the list and the last marker on the list (or the start of the
+ list if there is no marker on the list), then this is a
+ <span>parse error</span>; act as if an end tag with the tag
+ name "a" had been seen, then remove that element from the
+ <span>list of active formatting elements</span> and the
+ <span>stack of open elements</span> if the end tag didn't
+ already remove it (it might not have if the element is not
+ <span title="has an element in table scope">in table
+ scope</span>).</p>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <p class="example">In the non-conforming stream
+ <code><a href="a">a<table><a href="b">b</table>x</code>,
+ the first <code>a</code> element would be closed upon seeing
+ the second one, and the "x" character would be inside a link
+ to "b", not to "a". This is despite the fact that the outer
+ <code>a</code> element is not in table scope (meaning that a
+ regular <code></a></code> end tag at the start of the table
+ wouldn't close the outer <code>a</code> element).</p>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token. Add that element to the
- <span>list of active formatting elements</span>.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- </dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token. Add that element to the
+ <span>list of active formatting elements</span>.</p>
- <dt>A start tag whose tag name is one of: "b", "big", "em",
- "font", "i", "s", "small", "strike", "strong", "tt", "u"</dt>
- <dd>
+ </dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <dt>A start tag whose tag name is one of: "b", "big", "em",
+ "font", "i", "s", "small", "strike", "strong", "tt", "u"</dt>
+ <dd>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token. Add that element to the
- <span>list of active formatting elements</span>.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- </dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token. Add that element to the
+ <span>list of active formatting elements</span>.</p>
- <dt>A start tag whose tag name is "nobr"</dt>
- <dd>
+ </dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <dt>A start tag whose tag name is "nobr"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>nobr</code> element in
- scope</span>, then this is a <span>parse error</span>. Act as
- if an end tag with the tag name <code>nobr</code> had been
- seen, then once again <span>reconstruct the active formatting
- elements</span>, if any.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token. Add that element to the
- <span>list of active formatting elements</span>.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>nobr</code> element in
+ scope</span>, then this is a <span>parse error</span>. Act as
+ if an end tag with the tag name <code>nobr</code> had been
+ seen, then once again <span>reconstruct the active formatting
+ elements</span>, if any.</p>
- </dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token. Add that element to the
+ <span>list of active formatting elements</span>.</p>
- <dt id="adoptionAgency">An end tag whose tag name is one of:
- "a", "b", "big", "em", "font", "i", "nobr", "s", "small",
- "strike", "strong", "tt", "u"</dt>
- <dd>
+ </dd>
- <p>Follow these steps:</p>
+ <dt id="adoptionAgency">An end tag whose tag name is one of:
+ "a", "b", "big", "em", "font", "i", "nobr", "s", "small",
+ "strike", "strong", "tt", "u"</dt>
+ <dd>
- <ol>
+ <p>Follow these steps:</p>
- <li>
+ <ol>
- <p>Let the <var title="">formatting element</var> be the
- last element in the <span>list of active formatting
- elements</span> that:</p>
+ <li>
- <ul>
+ <p>Let the <var title="">formatting element</var> be the
+ last element in the <span>list of active formatting
+ elements</span> that:</p>
- <li>is between the end of the list and the last scope
- marker in the list, if any, or the start of the list
- otherwise, and</li>
+ <ul>
- <li>has the same tag name as the token.</li>
+ <li>is between the end of the list and the last scope
+ marker in the list, if any, or the start of the list
+ otherwise, and</li>
- </ul>
+ <li>has the same tag name as the token.</li>
- <p>If there is no such node, or, if that node is also in the
- <span>stack of open elements</span> but the element is not
- <span title="has an element in scope">in scope</span>, then
- this is a <span>parse error</span>. Abort these steps. The
- token is ignored.</p>
+ </ul>
- <p>Otherwise, if there is such a node, but that node is not
- in the <span>stack of open elements</span>, then this is a
- <span>parse error</span>; remove the element from the list,
- and abort these steps.</p>
+ <p>If there is no such node, or, if that node is also in the
+ <span>stack of open elements</span> but the element is not
+ <span title="has an element in scope">in scope</span>, then
+ this is a <span>parse error</span>. Abort these steps. The
+ token is ignored.</p>
- <p>Otherwise, there is a <var title="">formatting
- element</var> and that element is in <span title="stack of
- open elements">the stack</span> and is <span title="has an
- element in scope">in scope</span>. If the element is not the
- <span>current node</span>, this is a <span>parse
- error</span>. In any case, proceed with the algorithm as
- written in the following steps.</p>
+ <p>Otherwise, if there is such a node, but that node is not
+ in the <span>stack of open elements</span>, then this is a
+ <span>parse error</span>; remove the element from the list,
+ and abort these steps.</p>
- </li>
+ <p>Otherwise, there is a <var title="">formatting
+ element</var> and that element is in <span title="stack of
+ open elements">the stack</span> and is <span title="has an
+ element in scope">in scope</span>. If the element is not the
+ <span>current node</span>, this is a <span>parse
+ error</span>. In any case, proceed with the algorithm as
+ written in the following steps.</p>
- <li><p>Let the <var title="">furthest block</var> be the
- topmost node in the <span>stack of open elements</span> that
- is lower in the stack than the <var title="">formatting
- element</var>, and is not an element in the
- <span>phrasing</span> or <span>formatting</span>
- categories. There might not be one.</p></li>
+ </li>
- <li><p>If there is no <var title="">furthest block</var>,
- then the UA must skip the subsequent steps and instead just
- pop all the nodes from the bottom of the <span>stack of open
- elements</span>, from the <span>current node</span> up to and
- including the <var title="">formatting element</var>, and
- remove the <var title="">formatting element</var> from the
- <span>list of active formatting elements</span>.</p></li>
+ <li><p>Let the <var title="">furthest block</var> be the
+ topmost node in the <span>stack of open elements</span> that
+ is lower in the stack than the <var title="">formatting
+ element</var>, and is not an element in the
+ <span>phrasing</span> or <span>formatting</span>
+ categories. There might not be one.</p></li>
- <li><p>Let the <var title="">common ancestor</var> be the element
- immediately above the <var title="">formatting element</var> in the
- <span>stack of open elements</span>.</p></li>
+ <li><p>If there is no <var title="">furthest block</var>,
+ then the UA must skip the subsequent steps and instead just
+ pop all the nodes from the bottom of the <span>stack of open
+ elements</span>, from the <span>current node</span> up to and
+ including the <var title="">formatting element</var>, and
+ remove the <var title="">formatting element</var> from the
+ <span>list of active formatting elements</span>.</p></li>
- <li><p>If the <var title="">furthest block</var> has a parent node,
- then remove the <var title="">furthest block</var> from its parent
- node.</p></li>
+ <li><p>Let the <var title="">common ancestor</var> be the element
+ immediately above the <var title="">formatting element</var> in the
+ <span>stack of open elements</span>.</p></li>
- <li><p>Let a bookmark note the position of the <var
- title="">formatting element</var> in the <span>list of active
- formatting elements</span> relative to the elements on either
- side of it in the list.</p></li>
+ <li><p>If the <var title="">furthest block</var> has a parent node,
+ then remove the <var title="">furthest block</var> from its parent
+ node.</p></li>
- <li>
+ <li><p>Let a bookmark note the position of the <var
+ title="">formatting element</var> in the <span>list of active
+ formatting elements</span> relative to the elements on either
+ side of it in the list.</p></li>
- <p>Let <var title="">node</var> and <var title="">last node</var> be the
- <var title="">furthest block</var>. Follow these steps:</p>
+ <li>
- <ol>
+ <p>Let <var title="">node</var> and <var title="">last node</var> be the
+ <var title="">furthest block</var>. Follow these steps:</p>
- <li>Let <var title="">node</var> be the element immediately prior to
- <var title="">node</var> in the <span>stack of open
- elements</span>.</li>
+ <ol>
- <li>If <var title="">node</var> is not in the <span>list of
- active formatting elements</span>, then remove <var
- title="">node</var> from the <span>stack of open
- elements</span> and then go back to step 1.</li>
+ <li>Let <var title="">node</var> be the element immediately prior to
+ <var title="">node</var> in the <span>stack of open
+ elements</span>.</li>
- <li>Otherwise, if <var title="">node</var> is the <var
- title="">formatting element</var>, then go to the next step
- in the overall algorithm.</li>
+ <li>If <var title="">node</var> is not in the <span>list of
+ active formatting elements</span>, then remove <var
+ title="">node</var> from the <span>stack of open
+ elements</span> and then go back to step 1.</li>
- <li>Otherwise, if <var title="">last node</var> is the <var
- title="">furthest block</var>, then move the aforementioned
- bookmark to be immediately after the <var
- title="">node</var> in the <span>list of active formatting
- elements</span>.</li>
+ <li>Otherwise, if <var title="">node</var> is the <var
+ title="">formatting element</var>, then go to the next step
+ in the overall algorithm.</li>
- <li>If <var title="">node</var> has any children, perform a shallow
- clone of <var title="">node</var>, replace the entry for
- <var title="">node</var> in the <span>list of active formatting
- elements</span> with an entry for the clone, replace the
- entry for <var title="">node</var> in the <span>stack of open
- elements</span> with an entry for the clone, and let
- <var title="">node</var> be the clone.</li>
+ <li>Otherwise, if <var title="">last node</var> is the <var
+ title="">furthest block</var>, then move the aforementioned
+ bookmark to be immediately after the <var
+ title="">node</var> in the <span>list of active formatting
+ elements</span>.</li>
- <li>Insert <var title="">last node</var> into <var
- title="">node</var>, first removing it from its previous
- parent node if any.</li>
+ <li>If <var title="">node</var> has any children, perform a shallow
+ clone of <var title="">node</var>, replace the entry for
+ <var title="">node</var> in the <span>list of active formatting
+ elements</span> with an entry for the clone, replace the
+ entry for <var title="">node</var> in the <span>stack of open
+ elements</span> with an entry for the clone, and let
+ <var title="">node</var> be the clone.</li>
- <li>Let <var title="">last node</var> be <var title="">node</var>.</li>
+ <li>Insert <var title="">last node</var> into <var
+ title="">node</var>, first removing it from its previous
+ parent node if any.</li>
- <li>Return to step 1 of this inner set of steps.</li>
+ <li>Let <var title="">last node</var> be <var title="">node</var>.</li>
- </ol>
+ <li>Return to step 1 of this inner set of steps.</li>
- </li>
+ </ol>
- <li><p>Insert whatever <var title="">last node</var> ended up
- being in the previous step into the <var title="">common
- ancestor</var> node, first removing it from its previous
- parent node if any.</p></li>
+ </li>
- <li><p>Perform a shallow clone of the <var title="">formatting
- element</var>.</p></li>
+ <li><p>Insert whatever <var title="">last node</var> ended up
+ being in the previous step into the <var title="">common
+ ancestor</var> node, first removing it from its previous
+ parent node if any.</p></li>
- <li><p>Take all of the child nodes of the <var title="">furthest
- block</var> and append them to the clone created in the last
- step.</p></li>
+ <li><p>Perform a shallow clone of the <var title="">formatting
+ element</var>.</p></li>
- <li><p>Append that clone to the <var title="">furthest
- block</var>.</p></li>
+ <li><p>Take all of the child nodes of the <var title="">furthest
+ block</var> and append them to the clone created in the last
+ step.</p></li>
- <li><p>Remove the <var title="">formatting element</var> from the
- <span>list of active formatting elements</span>, and insert
- the clone into the <span>list of active formatting
- elements</span> at the position of the aforementioned
- bookmark.</p></li>
+ <li><p>Append that clone to the <var title="">furthest
+ block</var>.</p></li>
- <li><p>Remove the <var title="">formatting element</var> from the
- <span>stack of open elements</span>, and insert the clone
- into the <span>stack of open elements</span> immediately
- after (i.e. in a more deeply nested position than) the
- position of the <var title="">furthest block</var> in that
- stack.</p></li>
+ <li><p>Remove the <var title="">formatting element</var> from the
+ <span>list of active formatting elements</span>, and insert
+ the clone into the <span>list of active formatting
+ elements</span> at the position of the aforementioned
+ bookmark.</p></li>
- <li><p>Jump back to step 1 in this series of steps.</p></li>
+ <li><p>Remove the <var title="">formatting element</var> from the
+ <span>stack of open elements</span>, and insert the clone
+ into the <span>stack of open elements</span> immediately
+ after (i.e. in a more deeply nested position than) the
+ position of the <var title="">furthest block</var> in that
+ stack.</p></li>
- </ol>
+ <li><p>Jump back to step 1 in this series of steps.</p></li>
- <p class="note">The way these steps are defined, only elements
- in the <span>formatting</span> category ever get cloned by
- this algorithm.</p>
+ </ol>
+ <p class="note">The way these steps are defined, only elements
+ in the <span>formatting</span> category ever get cloned by
+ this algorithm.</p>
+
<!--XXX
- <div class="example">
- <p class="big-issue">Need an example.</p>
- </div>
+ <div class="example">
+ <p class="big-issue">Need an example.</p>
+ </div>
-->
- <p class="note">Because of the way this algorithm causes elements to
- change parents, it has been dubbed the "adoption agency algorithm"
- (in contrast with other possibly algorithms for dealing with
- misnested content, which included the "incest algorithm", the
- "secret affair algorithm", and the "Heisenberg algorithm").</p>
+ <p class="note">Because of the way this algorithm causes elements to
+ change parents, it has been dubbed the "adoption agency algorithm"
+ (in contrast with other possibly algorithms for dealing with
+ misnested content, which included the "incest algorithm", the
+ "secret affair algorithm", and the "Heisenberg algorithm").</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "button"</dt>
- <dd>
-
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>button</code> element in
- scope</span>, then this is a <span>parse error</span>;
- act as if an end tag with the tag name "button" had been seen,
- then reprocess the token.</p>
+ <dt>A start tag whose tag name is "button"</dt>
+ <dd>
- <p>Otherwise:</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>button</code> element in
+ scope</span>, then this is a <span>parse error</span>;
+ act as if an end tag with the tag name "button" had been seen,
+ then reprocess the token.</p>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <p>Otherwise:</p>
- <p><span>Insert an HTML element</span> for the token.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- <p>Insert a marker at the end of the <span>list of active
- formatting elements</span>.</p>
+ <p><span>Insert an HTML element</span> for the token.</p>
- </dd>
+ <p>Insert a marker at the end of the <span>list of active
+ formatting elements</span>.</p>
- <dt>A start tag token whose tag name is one of: "marquee",
- "object"</dt>
- <dd>
+ </dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <dt>A start tag token whose tag name is one of: "marquee",
+ "object"</dt>
+ <dd>
- <p><span>Insert an HTML element</span> for the token.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- <p>Insert a marker at the end of the <span>list of active
- formatting elements</span>.</p>
+ <p><span>Insert an HTML element</span> for the token.</p>
- </dd>
+ <p>Insert a marker at the end of the <span>list of active
+ formatting elements</span>.</p>
- <dt>An end tag token whose tag name is one of: "button",
- "marquee", "object"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has in scope</span> an element whose tag
- name is the same as the tag name of the token, then
- <span>generate implied end tags</span>.</p>
+ <dt>An end tag token whose tag name is one of: "button",
+ "marquee", "object"</dt>
+ <dd>
- <p>Now, if the <span>current node</span> is not an element
- with the same tag name as the token, then this is a
- <span>parse error</span>.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has in scope</span> an element whose tag
+ name is the same as the tag name of the token, then
+ <span>generate implied end tags</span>.</p>
- <p>Now, if the <span>stack of open elements</span> <span>has
- an element in scope</span> whose tag name matches the tag name
- of the token, then pop elements from the stack until that
- element has been popped from the stack, and <span>clear the
- list of active formatting elements up to the last
- marker</span>.</p>
+ <p>Now, if the <span>current node</span> is not an element
+ with the same tag name as the token, then this is a
+ <span>parse error</span>.</p>
- </dd>
+ <p>Now, if the <span>stack of open elements</span> <span>has
+ an element in scope</span> whose tag name matches the tag name
+ of the token, then pop elements from the stack until that
+ element has been popped from the stack, and <span>clear the
+ list of active formatting elements up to the last
+ marker</span>.</p>
- <dt>A start tag whose tag name is "xmp"</dt>
- <dd>
+ </dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <dt>A start tag whose tag name is "xmp"</dt>
+ <dd>
- <p>Follow the <span>generic CDATA parsing algorithm</span>,
- with the <span>current node</span> as the <var
- title="">context node</var>.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- </dd>
+ <p>Follow the <span>generic CDATA parsing algorithm</span>,
+ with the <span>current node</span> as the <var
+ title="">context node</var>.</p>
- <dt>A start tag whose tag name is "table"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
+ <dt>A start tag whose tag name is "table"</dt>
+ <dd>
- <p><span>Insert an HTML element</span> for the token.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: in table">in table</span>".</p>
+ <p><span>Insert an HTML element</span> for the token.</p>
- </dd>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: in table">in table</span>".</p>
- <dt>A start tag whose tag name is one of: "area", "basefont",
- "bgsound", "br", "embed", "img", "param", "spacer", "wbr"</dt>
- <dd>
+ </dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <dt>A start tag whose tag name is one of: "area", "basefont",
+ "bgsound", "br", "embed", "img", "param", "spacer", "wbr"</dt>
+ <dd>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token. Immediately pop the
- <span>current node</span> off the <span>stack of open
- elements</span>.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- </dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token. Immediately pop the
+ <span>current node</span> off the <span>stack of open
+ elements</span>.</p>
- <dt>A start tag whose tag name is "hr"</dt>
- <dd>
+ </dd>
- <p>If the <span>stack of open elements</span> <span title="has
- an element in scope">has a <code>p</code> element in
- scope</span>, then act as if an end tag with the tag name
- <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
+ <dt>A start tag whose tag name is "hr"</dt>
+ <dd>
- <p><span title="insert an html element">Insert an HTML
- element</span> for the token. Immediately pop the
- <span>current node</span> off the <span>stack of open
- elements</span>.</p>
+ <p>If the <span>stack of open elements</span> <span title="has
+ an element in scope">has a <code>p</code> element in
+ scope</span>, then act as if an end tag with the tag name
+ <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
- </dd>
+ <p><span title="insert an html element">Insert an HTML
+ element</span> for the token. Immediately pop the
+ <span>current node</span> off the <span>stack of open
+ elements</span>.</p>
- <dt>A start tag whose tag name is "image"</dt>
- <dd>
- <p><span>Parse error</span>. Change the token's tag name
- to "img" and reprocess it. (Don't ask.)</p> <!-- As of
- 2005-12, studies showed that around 0.2% of pages used the
- <image> element. -->
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "input"</dt>
- <dd>
+ <dt>A start tag whose tag name is "image"</dt>
+ <dd>
+ <p><span>Parse error</span>. Change the token's tag name
+ to "img" and reprocess it. (Don't ask.)</p> <!-- As of
+ 2005-12, studies showed that around 0.2% of pages used the
+ <image> element. -->
+ </dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <dt>A start tag whose tag name is "input"</dt>
+ <dd>
- <p><span title="insert an html element">Insert an
- <code>input</code> element</span> for the token.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- <p>If the <span><code title="">form</code> element
- pointer</span> is not null, then <span>associate</span><!--XXX
- xref! --> the <code>input</code> element with the
- <code>form</code> element pointed to by the <span><code
- title="">form</code> element pointer</span>.</p>
+ <p><span title="insert an html element">Insert an
+ <code>input</code> element</span> for the token.</p>
- <p>Pop that <code>input</code> element off the <span>stack of
- open elements</span>.</p>
+ <p>If the <span><code title="">form</code> element
+ pointer</span> is not null, then <span>associate</span><!--XXX
+ xref! --> the <code>input</code> element with the
+ <code>form</code> element pointed to by the <span><code
+ title="">form</code> element pointer</span>.</p>
- </dd>
+ <p>Pop that <code>input</code> element off the <span>stack of
+ open elements</span>.</p>
- <dt id="isindex">A start tag whose tag name is "isindex"</dt>
- <dd>
+ </dd>
- <p><span>Parse error</span>.</p>
+ <dt id="isindex">A start tag whose tag name is "isindex"</dt>
+ <dd>
- <p>If the <span><code title="">form</code> element
- pointer</span> is not null, then ignore the token.</p>
+ <p><span>Parse error</span>.</p>
- <p>Otherwise:</p>
+ <p>If the <span><code title="">form</code> element
+ pointer</span> is not null, then ignore the token.</p>
- <p>Act as if a start tag token with the tag name "form" had been seen.</p>
+ <p>Otherwise:</p>
- <p>If the token has an attribute called "action", set the
- <code title="attr-form-action">action</code> attribute on the
- resulting <code>form</code> element to the value of the
- "action" attribute of the token.</p>
+ <p>Act as if a start tag token with the tag name "form" had been seen.</p>
- <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
+ <p>If the token has an attribute called "action", set the
+ <code title="attr-form-action">action</code> attribute on the
+ resulting <code>form</code> element to the value of the
+ "action" attribute of the token.</p>
- <p>Act as if a start tag token with the tag name "p" had been seen.</p>
+ <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
- <p>Act as if a start tag token with the tag name "label" had been seen.</p
+ <p>Act as if a start tag token with the tag name "p" had been seen.</p>
- <p>Act as if a stream of character tokens had been seen (see
- below for what they should say).</p>
+ <p>Act as if a start tag token with the tag name "label" had been seen.</p
- <p>Act as if a start tag token with the tag name "input" had
- been seen, with all the attributes from the "isindex" token
- except "name", "action", and "prompt". Set the <code
- title="attr-input-name">name</code> attribute of the resulting
- <code>input</code> element to the value "<code
- title="">isindex</code>".</p>
+ <p>Act as if a stream of character tokens had been seen (see
+ below for what they should say).</p>
- <p>Act as if a stream of character tokens had been seen (see
- below for what they should say).</p>
+ <p>Act as if a start tag token with the tag name "input" had
+ been seen, with all the attributes from the "isindex" token
+ except "name", "action", and "prompt". Set the <code
+ title="attr-input-name">name</code> attribute of the resulting
+ <code>input</code> element to the value "<code
+ title="">isindex</code>".</p>
- <p>Act as if an end tag token with the tag name "label" had been seen.</p>
+ <p>Act as if a stream of character tokens had been seen (see
+ below for what they should say).</p>
- <p>Act as if an end tag token with the tag name "p" had been seen.</p>
+ <p>Act as if an end tag token with the tag name "label" had been seen.</p>
- <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
+ <p>Act as if an end tag token with the tag name "p" had been seen.</p>
- <p>Act as if an end tag token with the tag name "form" had been seen.</p>
+ <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
- <p>If the token has an attribute with the name "prompt", then
- the first stream of characters must be the same string as
- given in that attribute, and the second stream of characters
- must be empty. Otherwise, the two streams of character tokens
- together should, together with the <code>input</code> element,
- express the equivalent of "This is a searchable index. Insert
- your search keywords here: (input field)" in the user's
- preferred language.</p>
+ <p>Act as if an end tag token with the tag name "form" had been seen.</p>
- <p class="big-issue">
- Then need to specify that if the form submission causes just a single
- form control, whose name is "isindex", to be submitted, then we submit
- just the value part, not the "isindex=" part.
- </p>
+ <p>If the token has an attribute with the name "prompt", then
+ the first stream of characters must be the same string as
+ given in that attribute, and the second stream of characters
+ must be empty. Otherwise, the two streams of character tokens
+ together should, together with the <code>input</code> element,
+ express the equivalent of "This is a searchable index. Insert
+ your search keywords here: (input field)" in the user's
+ preferred language.</p>
- </dd>
+ <p class="big-issue">
+ Then need to specify that if the form submission causes just a single
+ form control, whose name is "isindex", to be submitted, then we submit
+ just the value part, not the "isindex=" part.
+ </p>
+ </dd>
+
<!-- XXX keygen support; don't forget form element pointer!
- <dt>A start tag whose tag name is "keygen"</dt>
- <dd>
- ...
- </dd>
+ <dt>A start tag whose tag name is "keygen"</dt>
+ <dd>
+ ...
+ </dd>
-->
- <dt>A start tag whose tag name is "textarea"</dt>
- <dd>
+ <dt>A start tag whose tag name is "textarea"</dt>
+ <dd>
- <p><span>Create an element for the token</span>.</p>
+ <p><span>Create an element for the token</span>.</p>
- <p>If the <span><code title="">form</code> element
- pointer</span> is not null, then <span>associate</span><!--XXX
- xref! --> the <code>textarea</code> element with the
- <code>form</code> element pointed to by the <span><code
- title="">form</code> element pointer</span>.</p>
+ <p>If the <span><code title="">form</code> element
+ pointer</span> is not null, then <span>associate</span><!--XXX
+ xref! --> the <code>textarea</code> element with the
+ <code>form</code> element pointed to by the <span><code
+ title="">form</code> element pointer</span>.</p>
- <p>Append the new element to the <span>current
- node</span>.</p>
+ <p>Append the new element to the <span>current
+ node</span>.</p>
- <p>Switch the tokeniser's <span>content model flag</span> to
- the RCDATA state.</p>
+ <p>Switch the tokeniser's <span>content model flag</span> to
+ the RCDATA state.</p>
- <p>If the next token is a U+000A LINE FEED (LF) character
- token, then ignore that token and move on to the next
- one. (Newlines at the start of <code>textarea</code> elements
- are ignored as an authoring convenience.)</p>
+ <p>If the next token is a U+000A LINE FEED (LF) character
+ token, then ignore that token and move on to the next
+ one. (Newlines at the start of <code>textarea</code> elements
+ are ignored as an authoring convenience.)</p>
- <p>Then, collect all the character tokens that the tokeniser
- returns until it returns a token that is not a character
- token, or until it stops tokenising.</p>
+ <p>Then, collect all the character tokens that the tokeniser
+ returns until it returns a token that is not a character
+ token, or until it stops tokenising.</p>
- <p>If this process resulted in a collection of character
- tokens, append a single <code>Text</code> node, whose contents
- is the concatenation of all those tokens' characters, to the
- new element node.</p>
+ <p>If this process resulted in a collection of character
+ tokens, append a single <code>Text</code> node, whose contents
+ is the concatenation of all those tokens' characters, to the
+ new element node.</p>
- <p>The tokeniser's <span>content model flag</span> will have
- switched back to the PCDATA state.</p>
+ <p>The tokeniser's <span>content model flag</span> will have
+ switched back to the PCDATA state.</p>
- <p>If the next token is an end tag token with the tag name
- "textarea", ignore it. Otherwise, this is a <span>parse
- error</span>.</p>
+ <p>If the next token is an end tag token with the tag name
+ "textarea", ignore it. Otherwise, this is a <span>parse
+ error</span>.</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is one of: "iframe",
- "noembed", "noframes"</dt>
- <dt>A start tag whose tag name is "noscript", if
- <span>scripting is enabled</span>:</dt>
- <dd>
+ <dt>A start tag whose tag name is one of: "iframe",
+ "noembed", "noframes"</dt>
+ <dt>A start tag whose tag name is "noscript", if
+ <span>scripting is enabled</span>:</dt>
+ <dd>
- <p>Follow the <span>generic CDATA parsing algorithm</span>,
- with the <span>current node</span> as the <var
- title="">context node</var>.</p>
+ <p>Follow the <span>generic CDATA parsing algorithm</span>,
+ with the <span>current node</span> as the <var
+ title="">context node</var>.</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "select"</dt>
- <dd>
+ <dt>A start tag whose tag name is "select"</dt>
+ <dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- <p><span>Insert an HTML element</span> for the token.</p>
+ <p><span>Insert an HTML element</span> for the token.</p>
- <p>Change the <span>insertion mode</span> to "<span
- title="insertion mode: in select">in select</span>".</p>
+ <p>Change the <span>insertion mode</span> to "<span
+ title="insertion mode: in select">in select</span>".</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "br"</dt>
- <dd>
- <p><span>Parse error</span>. Act as if a start tag token with
- the tag name "br" had been seen. Ignore the end tag token.</p>
- </dd>
+ <dt>An end tag whose tag name is "br"</dt>
+ <dd>
+ <p><span>Parse error</span>. Act as if a start tag token with
+ the tag name "br" had been seen. Ignore the end tag token.</p>
+ </dd>
- <dt>A start or end tag whose tag name is one of: "caption",
- "col", "colgroup", "frame", "frameset", "head", "option",
- "optgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
- <dt>An end tag whose tag name is one of: "area", "basefont",
- "bgsound", <!--XXX quirks: remove br-->"br", "embed", "hr",
- "iframe", "image", "img", "input", "isindex", "noembed",
- "noframes", "param", "select", "spacer", "table", "textarea",
- "wbr"</dt> <!-- add keygen if we add the start tag -->
- <dt>An end tag whose tag name is "noscript", if <span>scripting
- is enabled</span>:</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A start or end tag whose tag name is one of: "caption",
+ "col", "colgroup", "frame", "frameset", "head", "option",
+ "optgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
+ <dt>An end tag whose tag name is one of: "area", "basefont",
+ "bgsound", <!--XXX quirks: remove br-->"br", "embed", "hr",
+ "iframe", "image", "img", "input", "isindex", "noembed",
+ "noframes", "param", "select", "spacer", "table", "textarea",
+ "wbr"</dt> <!-- add keygen if we add the start tag -->
+ <dt>An end tag whose tag name is "noscript", if <span>scripting
+ is enabled</span>:</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start or end tag whose tag name is one of:
- "event-source", "section", "nav", "article", "aside", "header",
- "footer", "datagrid", "command"</dt>
+ <dt>A start or end tag whose tag name is one of:
+ "event-source", "section", "nav", "article", "aside", "header",
+ "footer", "datagrid", "command"</dt>
- <dd>
+ <dd>
- <!-- XXXX -->
+ <!-- XXXX -->
- <p class="big-issue">Work in progress!</p>
+ <p class="big-issue">Work in progress!</p>
- </dd>
+ </dd>
- <dt>A start tag token not covered by the previous entries</dt>
- <dd>
+ <dt>A start tag token not covered by the previous entries</dt>
+ <dd>
- <p><span>Reconstruct the active formatting elements</span>, if
- any.</p>
+ <p><span>Reconstruct the active formatting elements</span>, if
+ any.</p>
- <p><span>Insert an HTML element</span> for the token.</p>
+ <p><span>Insert an HTML element</span> for the token.</p>
- <p class="note">This element will be a <span>phrasing</span>
- element.</p>
+ <p class="note">This element will be a <span>phrasing</span>
+ element.</p>
<!--
Put the following into the MathML namespace if parsed:
- math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded,
- mphantom, mfenced, menclose, msub, msup, msubsup, munder,
- mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr,
- mtd, maction
+math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded,
+mphantom, mfenced, menclose, msub, msup, msubsup, munder,
+mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr,
+mtd, maction
-->
- </dd>
+ </dd>
- <dt>An end tag token not covered by the previous entries</dt>
- <dd>
+ <dt>An end tag token not covered by the previous entries</dt>
+ <dd>
- <p>Run the following algorithm:</p>
+ <p>Run the following algorithm:</p>
- <ol>
+ <ol>
- <li><p>Initialise <var title="">node</var> to be the <span>current
- node</span> (the bottommost node of the stack).</p></li>
+ <li><p>Initialise <var title="">node</var> to be the <span>current
+ node</span> (the bottommost node of the stack).</p></li>
- <li><p>If <var title="">node</var> has the same tag name as
- the end tag token, then:</p>
+ <li><p>If <var title="">node</var> has the same tag name as
+ the end tag token, then:</p>
- <ol>
+ <ol>
- <li><p><span>Generate implied end tags</span>.</p></li>
+ <li><p><span>Generate implied end tags</span>.</p></li>
- <li><p>If the tag name of the end tag token does not match
- the tag name of the <span>current node</span>, this is a
- <span>parse error</span>.</p></li>
+ <li><p>If the tag name of the end tag token does not match
+ the tag name of the <span>current node</span>, this is a
+ <span>parse error</span>.</p></li>
- <li><p>Pop all the nodes from the <span>current node</span>
- up to <var title="">node</var>, including <var title="">node</var>, then stop
- this algorithm.</p></li>
+ <li><p>Pop all the nodes from the <span>current node</span>
+ up to <var title="">node</var>, including <var title="">node</var>, then stop
+ this algorithm.</p></li>
- </ol>
+ </ol>
- </li>
+ </li>
- <li><p>Otherwise, if <var title="">node</var> is in neither
- the <span>formatting</span> category nor the
- <span>phrasing</span> category, then this is a <span>parse
- error</span>. Stop this algorithm. The end tag token is
- ignored.</p></li>
+ <li><p>Otherwise, if <var title="">node</var> is in neither
+ the <span>formatting</span> category nor the
+ <span>phrasing</span> category, then this is a <span>parse
+ error</span>. Stop this algorithm. The end tag token is
+ ignored.</p></li>
- <li><p>Set <var title="">node</var> to the previous entry in the
- <span>stack of open elements</span>.</p></li>
+ <li><p>Set <var title="">node</var> to the previous entry in the
+ <span>stack of open elements</span>.</p></li>
- <li><p>Return to step 2.</p></li>
+ <li><p>Return to step 2.</p></li>
- </ol>
+ </ol>
- </dd>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-intable">The <dfn title="insertion mode: in table">in table</dfn> insertion mode</h6>
+ <h6 id="parsing-main-intable">The <dfn title="insertion mode: in table">in table</dfn> insertion mode</h6>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p><span title="append a character">Append the character</span> to
- the <span>current node</span>.</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p><span title="append a character">Append the character</span> to
+ the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is "caption"</dt>
- <dd>
+ <dt>A start tag whose tag name is "caption"</dt>
+ <dd>
- <p><span>Clear the stack back to a table context</span>. (See
- below.)</p>
+ <p><span>Clear the stack back to a table context</span>. (See
+ below.)</p>
- <p>Insert a marker at the end of the <span>list of active
- formatting elements</span>.</p>
+ <p>Insert a marker at the end of the <span>list of active
+ formatting elements</span>.</p>
- <p><span>Insert an HTML element</span> for the token, then
- switch the <span>insertion mode</span> to "<span
- title="insertion mode: in caption">in caption</span>".</p>
+ <p><span>Insert an HTML element</span> for the token, then
+ switch the <span>insertion mode</span> to "<span
+ title="insertion mode: in caption">in caption</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "colgroup"</dt>
- <dd>
+ <dt>A start tag whose tag name is "colgroup"</dt>
+ <dd>
- <p><span>Clear the stack back to a table context</span>. (See
- below.)</p>
+ <p><span>Clear the stack back to a table context</span>. (See
+ below.)</p>
- <p><span>Insert an HTML element</span> for the token, then
- switch the <span>insertion mode</span> to "<span
- title="insertion mode: in column group">in column
- group</span>".</p>
+ <p><span>Insert an HTML element</span> for the token, then
+ switch the <span>insertion mode</span> to "<span
+ title="insertion mode: in column group">in column
+ group</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "col"</dt>
- <dd>
- <p>Act as if a start tag token with the tag name "colgroup"
- had been seen, then reprocess the current token.</p>
- </dd>
+ <dt>A start tag whose tag name is "col"</dt>
+ <dd>
+ <p>Act as if a start tag token with the tag name "colgroup"
+ had been seen, then reprocess the current token.</p>
+ </dd>
- <dt>A start tag whose tag name is one of: "tbody", "tfoot", "thead"</dt>
- <dd>
+ <dt>A start tag whose tag name is one of: "tbody", "tfoot", "thead"</dt>
+ <dd>
- <p><span>Clear the stack back to a table context</span>. (See
- below.)</p>
+ <p><span>Clear the stack back to a table context</span>. (See
+ below.)</p>
- <p><span>Insert an HTML element</span> for the token, then
- switch the <span>insertion mode</span> to "<span
- title="insertion mode: in table body">in table
- body</span>".</p>
+ <p><span>Insert an HTML element</span> for the token, then
+ switch the <span>insertion mode</span> to "<span
+ title="insertion mode: in table body">in table
+ body</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is one of: "td", "th", "tr"</dt>
- <dd>
- <p>Act as if a start tag token with the tag name "tbody" had
- been seen, then reprocess the current token.</p>
- </dd>
+ <dt>A start tag whose tag name is one of: "td", "th", "tr"</dt>
+ <dd>
+ <p>Act as if a start tag token with the tag name "tbody" had
+ been seen, then reprocess the current token.</p>
+ </dd>
- <dt>A start tag whose tag name is "table"</dt>
- <dd>
+ <dt>A start tag whose tag name is "table"</dt>
+ <dd>
- <p><span>Parse error</span>. Act as if an end tag token with
- the tag name "table" had been seen, then, if that token wasn't
- ignored, reprocess the current token.</p>
+ <p><span>Parse error</span>. Act as if an end tag token with
+ the tag name "table" had been seen, then, if that token wasn't
+ ignored, reprocess the current token.</p>
- <p class="note">The fake end tag token here can only be
- ignored in the <span>fragment case</span>.</p>
+ <p class="note">The fake end tag token here can only be
+ ignored in the <span>fragment case</span>.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "table"</dt>
- <dd>
+ <dt>An end tag whose tag name is "table"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as the token, this is a
- <span>parse error</span>. Ignore the token. (<span>fragment
- case</span>)</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as the token, this is a
+ <span>parse error</span>. Ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Otherwise:</p>
+ <p>Otherwise:</p>
- <p><span>Generate implied end tags</span>.</p>
+ <p><span>Generate implied end tags</span>.</p>
- <p>Now, if the <span>current node</span> is not a
- <code>table</code> element, then this is a <span>parse
- error</span>.</p>
+ <p>Now, if the <span>current node</span> is not a
+ <code>table</code> element, then this is a <span>parse
+ error</span>.</p>
- <p>Pop elements from this stack until a <code>table</code>
- element has been popped from the stack.</p>
+ <p>Pop elements from this stack until a <code>table</code>
+ element has been popped from the stack.</p>
- <p><span>Reset the insertion mode appropriately</span>.</p>
+ <p><span>Reset the insertion mode appropriately</span>.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "body", "caption",
- "col", "colgroup", "html", "tbody", "td", "tfoot", "th",
- "thead", "tr"</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>An end tag whose tag name is one of: "body", "caption",
+ "col", "colgroup", "html", "tbody", "td", "tfoot", "th",
+ "thead", "tr"</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
+ <dt>Anything else</dt>
+ <dd>
- <p><span>Parse error</span>. Process the token as if the
- <span>insertion mode</span> was "<span title="insertion mode:
- in body">in body</span>", with the following exception:</p>
+ <p><span>Parse error</span>. Process the token as if the
+ <span>insertion mode</span> was "<span title="insertion mode:
+ in body">in body</span>", with the following exception:</p>
- <p>If the <span>current node</span> is a <code>table</code>,
- <code>tbody</code>, <code>tfoot</code>, <code>thead</code>, or
- <code>tr</code> element, then, whenever a node would be
- inserted into the <span>current node</span>, it must instead
- be inserted into the <em>foster parent element</em>.</p>
+ <p>If the <span>current node</span> is a <code>table</code>,
+ <code>tbody</code>, <code>tfoot</code>, <code>thead</code>, or
+ <code>tr</code> element, then, whenever a node would be
+ inserted into the <span>current node</span>, it must instead
+ be inserted into the <em>foster parent element</em>.</p>
- <p>The <dfn>foster parent element</dfn> is the parent element
- of the last <code>table</code> element in the <span>stack of
- open elements</span>, if there is a <code>table</code> element
- and it has such a parent element. If there is no
- <code>table</code> element in the <span>stack of open
- elements</span> (<span>fragment case</span>), then the
- <em>foster parent element</em> is the first element in the
- <span>stack of open elements</span> (the <code>html</code>
- element). Otherwise, if there is a <code>table</code> element
- in the <span>stack of open elements</span>, but the last
- <code>table</code> element in the <span>stack of open
- elements</span> has no parent, or its parent node is not an
- element, then the <em>foster parent element</em> is the
- element before the last <code>table</code> element in the
- <span>stack of open elements</span>.</p>
+ <p>The <dfn>foster parent element</dfn> is the parent element
+ of the last <code>table</code> element in the <span>stack of
+ open elements</span>, if there is a <code>table</code> element
+ and it has such a parent element. If there is no
+ <code>table</code> element in the <span>stack of open
+ elements</span> (<span>fragment case</span>), then the
+ <em>foster parent element</em> is the first element in the
+ <span>stack of open elements</span> (the <code>html</code>
+ element). Otherwise, if there is a <code>table</code> element
+ in the <span>stack of open elements</span>, but the last
+ <code>table</code> element in the <span>stack of open
+ elements</span> has no parent, or its parent node is not an
+ element, then the <em>foster parent element</em> is the
+ element before the last <code>table</code> element in the
+ <span>stack of open elements</span>.</p>
- <p>If the <em>foster parent element</em> is the parent element
- of the last <code>table</code> element in the <span>stack of
- open elements</span>, then the new node must be inserted
- immediately <em>before</em> the last <code>table</code>
- element in the <span>stack of open elements</span> in the
- <span>foster parent element</span>; otherwise, the new node
- must be <em>appended</em> to the <span>foster parent
- element</span>.</p>
+ <p>If the <em>foster parent element</em> is the parent element
+ of the last <code>table</code> element in the <span>stack of
+ open elements</span>, then the new node must be inserted
+ immediately <em>before</em> the last <code>table</code>
+ element in the <span>stack of open elements</span> in the
+ <span>foster parent element</span>; otherwise, the new node
+ must be <em>appended</em> to the <span>foster parent
+ element</span>.</p>
- </dd>
+ </dd>
- </dl>
+ </dl>
- <p>When the steps above require the UA to <dfn>clear the stack
- back to a table context</dfn>, it means that the UA must, while
- the <span>current node</span> is not a <code>table</code>
- element or an <code>html</code> element, pop elements from the
- <span>stack of open elements</span>. If this causes any elements
- to be popped from the stack, then this is a <span>parse
- error</span>.</p>
+ <p>When the steps above require the UA to <dfn>clear the stack
+ back to a table context</dfn>, it means that the UA must, while
+ the <span>current node</span> is not a <code>table</code>
+ element or an <code>html</code> element, pop elements from the
+ <span>stack of open elements</span>. If this causes any elements
+ to be popped from the stack, then this is a <span>parse
+ error</span>.</p>
- <p class="note">The <span>current node</span> being an
- <code>html</code> element after this process is a <span>fragment
- case</span>.</p>
+ <p class="note">The <span>current node</span> being an
+ <code>html</code> element after this process is a <span>fragment
+ case</span>.</p>
- <h6 id="parsing-main-incaption">The <dfn title="insertion mode: in caption">in caption</dfn> insertion mode</h6>
+ <h6 id="parsing-main-incaption">The <dfn title="insertion mode: in caption">in caption</dfn> insertion mode</h6>
- <p>Handle the token as follows.</p>
+ <p>Handle the token as follows.</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end tag whose tag name is "caption"</dt>
- <dd>
+ <dt>An end tag whose tag name is "caption"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as the token, this is a
- <span>parse error</span>. Ignore the token. (<span>fragment
- case</span>)</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as the token, this is a
+ <span>parse error</span>. Ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Otherwise:</p>
+ <p>Otherwise:</p>
- <p><span>Generate implied end tags</span>.</p>
+ <p><span>Generate implied end tags</span>.</p>
- <p>Now, if the <span>current node</span> is not a
- <code>caption</code> element, then this is a <span>parse
- error</span>.</p>
+ <p>Now, if the <span>current node</span> is not a
+ <code>caption</code> element, then this is a <span>parse
+ error</span>.</p>
- <p>Pop elements from this stack until a <code>caption</code>
- element has been popped from the stack.</p>
+ <p>Pop elements from this stack until a <code>caption</code>
+ element has been popped from the stack.</p>
- <p><span>Clear the list of active formatting elements up to
- the last marker</span>.</p>
+ <p><span>Clear the list of active formatting elements up to
+ the last marker</span>.</p>
- <p>Switch the <span>insertion mode</span> to "<span
- title="insertion mode: in table">in table</span>".</p>
+ <p>Switch the <span>insertion mode</span> to "<span
+ title="insertion mode: in table">in table</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is one of: "caption", "col",
- "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
- <dt>An end tag whose tag name is "table"</dt>
- <dd>
+ <dt>A start tag whose tag name is one of: "caption", "col",
+ "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
+ <dt>An end tag whose tag name is "table"</dt>
+ <dd>
- <p><span>Parse error</span>. Act as if an end tag with the tag
- name "caption" had been seen, then, if that token wasn't
- ignored, reprocess the current token.</p>
+ <p><span>Parse error</span>. Act as if an end tag with the tag
+ name "caption" had been seen, then, if that token wasn't
+ ignored, reprocess the current token.</p>
- <p class="note">The fake end tag token here can only be
- ignored in the <span>fragment case</span>.</p>
+ <p class="note">The fake end tag token here can only be
+ ignored in the <span>fragment case</span>.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "body", "col",
- "colgroup", "html", "tbody", "td", "tfoot", "th", "thead",
- "tr"</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>An end tag whose tag name is one of: "body", "col",
+ "colgroup", "html", "tbody", "td", "tfoot", "th", "thead",
+ "tr"</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> was
- "<span title="insertion mode: in body">in body</span>".</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> was
+ "<span title="insertion mode: in body">in body</span>".</p>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-incolgroup">The <dfn title="insertion mode: in column group">in column group</dfn> insertion mode</h6>
+ <h6 id="parsing-main-incolgroup">The <dfn title="insertion mode: in column group">in column group</dfn> insertion mode</h6>
- <p>Handle the token as follows.</p>
+ <p>Handle the token as follows.</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p><span title="append a character">Append the character</span> to
- the <span>current node</span>.</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p><span title="append a character">Append the character</span> to
+ the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is "col"</dt>
- <dd>
- <p><span title="insert an HTML element">Insert a
- <code>col</code> element</span> for the token. Immediately
- pop the <span>current node</span> off the <span>stack of open
- elements</span>.</p>
- </dd>
+ <dt>A start tag whose tag name is "col"</dt>
+ <dd>
+ <p><span title="insert an HTML element">Insert a
+ <code>col</code> element</span> for the token. Immediately
+ pop the <span>current node</span> off the <span>stack of open
+ elements</span>.</p>
+ </dd>
- <dt>An end tag whose tag name is "colgroup"</dt>
- <dd>
+ <dt>An end tag whose tag name is "colgroup"</dt>
+ <dd>
- <p>If the <span>current node</span> is the root
- <code>html</code> element, then this is a <span>parse
- error</span>, ignore the token. (<span>fragment
- case</span>)</p>
+ <p>If the <span>current node</span> is the root
+ <code>html</code> element, then this is a <span>parse
+ error</span>, ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Otherwise, pop the <span>current node</span> (which will be
- a <code>colgroup</code> element) from the <span>stack of open
- elements</span>. Switch the <span>insertion mode</span> to
- "<span title="insertion mode: in table">in table</span>".</p>
+ <p>Otherwise, pop the <span>current node</span> (which will be
+ a <code>colgroup</code> element) from the <span>stack of open
+ elements</span>. Switch the <span>insertion mode</span> to
+ "<span title="insertion mode: in table">in table</span>".</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "col"</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>An end tag whose tag name is "col"</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
+ <dt>Anything else</dt>
+ <dd>
- <p>Act as if an end tag with the tag name "colgroup" had been
- seen, and then, if that token wasn't ignored, reprocess the
- current token.</p>
+ <p>Act as if an end tag with the tag name "colgroup" had been
+ seen, and then, if that token wasn't ignored, reprocess the
+ current token.</p>
- <p class="note">The fake end tag token here can only be
- ignored in the <span>fragment case</span>.</p>
+ <p class="note">The fake end tag token here can only be
+ ignored in the <span>fragment case</span>.</p>
- </dd>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-intbody">The <dfn title="insertion mode: in table body">in table body</dfn> insertion mode</h6>
+ <h6 id="parsing-main-intbody">The <dfn title="insertion mode: in table body">in table body</dfn> insertion mode</h6>
- <p>Handle the token as follows.</p>
+ <p>Handle the token as follows.</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>A start tag whose tag name is "tr"</dt>
- <dd>
+ <dt>A start tag whose tag name is "tr"</dt>
+ <dd>
- <p><span>Clear the stack back to a table body
- context</span>. (See below.)</p>
+ <p><span>Clear the stack back to a table body
+ context</span>. (See below.)</p>
- <p><span title="insert an HTML element">Insert a
- <code>tr</code> element</span> for the token, then switch the
- <span>insertion mode</span> to "<span title="insertion mode:
- in row">in row</span>".</p>
+ <p><span title="insert an HTML element">Insert a
+ <code>tr</code> element</span> for the token, then switch the
+ <span>insertion mode</span> to "<span title="insertion mode:
+ in row">in row</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is one of: "th", "td"</dt>
- <dd>
- <p><span>Parse error</span>. Act as if a start tag with
- the tag name "tr" had been seen, then reprocess the current
- token.</p>
- </dd>
+ <dt>A start tag whose tag name is one of: "th", "td"</dt>
+ <dd>
+ <p><span>Parse error</span>. Act as if a start tag with
+ the tag name "tr" had been seen, then reprocess the current
+ token.</p>
+ </dd>
- <dt>An end tag whose tag name is one of: "tbody", "tfoot",
- "thead"</dt>
- <dd>
+ <dt>An end tag whose tag name is one of: "tbody", "tfoot",
+ "thead"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as the token, this is a
- <span>parse error</span>. Ignore the token.</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as the token, this is a
+ <span>parse error</span>. Ignore the token.</p>
- <p>Otherwise:</p>
+ <p>Otherwise:</p>
- <p><span>Clear the stack back to a table body
- context</span>. (See below.)</p>
+ <p><span>Clear the stack back to a table body
+ context</span>. (See below.)</p>
- <p>Pop the <span>current node</span> from the <span>stack of
- open elements</span>. Switch the <span>insertion mode</span>
- to "<span title="insertion mode: in table">in table</span>".</p>
+ <p>Pop the <span>current node</span> from the <span>stack of
+ open elements</span>. Switch the <span>insertion mode</span>
+ to "<span title="insertion mode: in table">in table</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is one of: "caption", "col",
- "colgroup", "tbody", "tfoot", "thead"</dt>
- <dt>An end tag whose tag name is "table"</dt>
- <dd>
+ <dt>A start tag whose tag name is one of: "caption", "col",
+ "colgroup", "tbody", "tfoot", "thead"</dt>
+ <dt>An end tag whose tag name is "table"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have a
- <code>tbody</code>, <code>thead</code>, or <code>tfoot</code>
- element in table scope</span>, this is a <span>parse
- error</span>. Ignore the token. (<span>fragment
- case</span>)</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have a
+ <code>tbody</code>, <code>thead</code>, or <code>tfoot</code>
+ element in table scope</span>, this is a <span>parse
+ error</span>. Ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Otherwise:</p>
+ <p>Otherwise:</p>
- <p><span>Clear the stack back to a table body
- context</span>. (See below.)</p>
+ <p><span>Clear the stack back to a table body
+ context</span>. (See below.)</p>
- <p>Act as if an end tag with the same tag name as the
- <span>current node</span> ("tbody", "tfoot", or "thead") had
- been seen, then reprocess the current token.</p>
+ <p>Act as if an end tag with the same tag name as the
+ <span>current node</span> ("tbody", "tfoot", or "thead") had
+ been seen, then reprocess the current token.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "body", "caption",
- "col", "colgroup", "html", "td", "th", "tr"</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>An end tag whose tag name is one of: "body", "caption",
+ "col", "colgroup", "html", "td", "th", "tr"</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> was
- "<span title="insertion mode: in table">in table</span>".</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> was
+ "<span title="insertion mode: in table">in table</span>".</p>
+ </dd>
- </dl>
+ </dl>
- <p>When the steps above require the UA to <dfn>clear the stack
- back to a table body context</dfn>, it means that the UA must,
- while the <span>current node</span> is not a <code>tbody</code>,
- <code>tfoot</code>, <code>thead</code>, or <code>html</code>
- element, pop elements from the <span>stack of open
- elements</span>. If this causes any elements to be popped from
- the stack, then this is a
- <span>parse error</span>.</p>
+ <p>When the steps above require the UA to <dfn>clear the stack
+ back to a table body context</dfn>, it means that the UA must,
+ while the <span>current node</span> is not a <code>tbody</code>,
+ <code>tfoot</code>, <code>thead</code>, or <code>html</code>
+ element, pop elements from the <span>stack of open
+ elements</span>. If this causes any elements to be popped from
+ the stack, then this is a
+ <span>parse error</span>.</p>
- <p class="note">The <span>current node</span> being an
- <code>html</code> element after this process is a <span>fragment
- case</span>.</p>
+ <p class="note">The <span>current node</span> being an
+ <code>html</code> element after this process is a <span>fragment
+ case</span>.</p>
- <h6 id="parsing-main-intr">The <dfn title="insertion mode: in row">in row</dfn> insertion mode</h6>
+ <h6 id="parsing-main-intr">The <dfn title="insertion mode: in row">in row</dfn> insertion mode</h6>
- <p>Handle the token as follows.</p>
+ <p>Handle the token as follows.</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>A start tag whose tag name is one of: "th", "td"</dt>
- <dd>
+ <dt>A start tag whose tag name is one of: "th", "td"</dt>
+ <dd>
- <p><span>Clear the stack back to a table row
- context</span>. (See below.)</p>
+ <p><span>Clear the stack back to a table row
+ context</span>. (See below.)</p>
- <p><span title="insert an HTML element">Insert an HTML
- element</span> for the token, then switch the <span>insertion
- mode</span> to "<span title="insertion mode: in cell">in
- cell</span>".</p>
+ <p><span title="insert an HTML element">Insert an HTML
+ element</span> for the token, then switch the <span>insertion
+ mode</span> to "<span title="insertion mode: in cell">in
+ cell</span>".</p>
- <p>Insert a marker at the end of the <span>list of active
- formatting elements</span>.</p>
+ <p>Insert a marker at the end of the <span>list of active
+ formatting elements</span>.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "tr"</dt>
- <dd>
+ <dt>An end tag whose tag name is "tr"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as the token, this is a
- <span>parse error</span>. Ignore the token. (<span>fragment
- case</span>)</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as the token, this is a
+ <span>parse error</span>. Ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Otherwise:</p>
+ <p>Otherwise:</p>
- <p><span>Clear the stack back to a table row
- context</span>. (See below.)</p>
+ <p><span>Clear the stack back to a table row
+ context</span>. (See below.)</p>
- <p>Pop the <span>current node</span> (which will be a
- <code>tr</code> element) from the <span>stack of open
- elements</span>. Switch the <span>insertion mode</span> to
- "<span title="insertion mode: in table body">in table
- body</span>".</p>
+ <p>Pop the <span>current node</span> (which will be a
+ <code>tr</code> element) from the <span>stack of open
+ elements</span>. Switch the <span>insertion mode</span> to
+ "<span title="insertion mode: in table body">in table
+ body</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is one of: "caption", "col",
- "colgroup", "tbody", "tfoot", "thead", "tr"</dt>
- <dt>An end tag whose tag name is "table"</dt>
- <dd>
+ <dt>A start tag whose tag name is one of: "caption", "col",
+ "colgroup", "tbody", "tfoot", "thead", "tr"</dt>
+ <dt>An end tag whose tag name is "table"</dt>
+ <dd>
- <p>Act as if an end tag with the tag name "tr" had been seen,
- then, if that token wasn't ignored, reprocess the current
- token.</p>
+ <p>Act as if an end tag with the tag name "tr" had been seen,
+ then, if that token wasn't ignored, reprocess the current
+ token.</p>
- <p class="note">The fake end tag token here can only be
- ignored in the <span>fragment case</span>.</p>
+ <p class="note">The fake end tag token here can only be
+ ignored in the <span>fragment case</span>.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "tbody", "tfoot",
- "thead"</dt>
- <dd>
+ <dt>An end tag whose tag name is one of: "tbody", "tfoot",
+ "thead"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as the token, this is a
- <span>parse error</span>. Ignore the token.</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as the token, this is a
+ <span>parse error</span>. Ignore the token.</p>
- <p>Otherwise, act as if an end tag with the tag name "tr" had
- been seen, then reprocess the current token.</p>
+ <p>Otherwise, act as if an end tag with the tag name "tr" had
+ been seen, then reprocess the current token.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "body", "caption",
- "col", "colgroup", "html", "td", "th"</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>An end tag whose tag name is one of: "body", "caption",
+ "col", "colgroup", "html", "td", "th"</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> was
- "<span title="insertion mode: in table">in table</span>".</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> was
+ "<span title="insertion mode: in table">in table</span>".</p>
+ </dd>
- </dl>
+ </dl>
- <p>When the steps above require the UA to <dfn>clear the stack
- back to a table row context</dfn>, it means that the UA must,
- while the <span>current node</span> is not a <code>tr</code>
- element or an <code>html</code> element, pop elements from the
- <span>stack of open elements</span>. If this causes any elements
- to be popped from the stack, then this is a <span>parse
- error</span>.</p>
+ <p>When the steps above require the UA to <dfn>clear the stack
+ back to a table row context</dfn>, it means that the UA must,
+ while the <span>current node</span> is not a <code>tr</code>
+ element or an <code>html</code> element, pop elements from the
+ <span>stack of open elements</span>. If this causes any elements
+ to be popped from the stack, then this is a <span>parse
+ error</span>.</p>
- <p class="note">The <span>current node</span> being an
- <code>html</code> element after this process is a <span>fragment
- case</span>.</p>
+ <p class="note">The <span>current node</span> being an
+ <code>html</code> element after this process is a <span>fragment
+ case</span>.</p>
- <h6 id="parsing-main-intd">The <dfn title="insertion mode: in cell">in cell</dfn> insertion mode</h6>
+ <h6 id="parsing-main-intd">The <dfn title="insertion mode: in cell">in cell</dfn> insertion mode</h6>
- <p>Handle the token as follows.</p>
+ <p>Handle the token as follows.</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end tag whose tag name is one of: "td", "th"</dt>
- <dd>
+ <dt>An end tag whose tag name is one of: "td", "th"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as that of the token, then
- this is a <span>parse error</span> and the token must be
- ignored.</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as that of the token, then
+ this is a <span>parse error</span> and the token must be
+ ignored.</p>
- <p>Otherwise:</p>
+ <p>Otherwise:</p>
- <p><span>Generate implied end tags</span>, except for elements
- with the same tag name as the token.</p>
+ <p><span>Generate implied end tags</span>, except for elements
+ with the same tag name as the token.</p>
- <p>Now, if the <span>current node</span> is not an element
- with the same tag name as the token, then this is a
- <span>parse error</span>.</p>
+ <p>Now, if the <span>current node</span> is not an element
+ with the same tag name as the token, then this is a
+ <span>parse error</span>.</p>
- <p>Pop elements from this stack until an element with the same
- tag name as the token has been popped from the stack.</p>
+ <p>Pop elements from this stack until an element with the same
+ tag name as the token has been popped from the stack.</p>
- <p><span>Clear the list of active formatting elements up to
- the last marker</span>.</p>
+ <p><span>Clear the list of active formatting elements up to
+ the last marker</span>.</p>
- <p>Switch the <span>insertion mode</span> to "<span
- title="insertion mode: in row">in row</span>". (The
- <span>current node</span> will be a <code>tr</code> element at
- this point.)</p>
+ <p>Switch the <span>insertion mode</span> to "<span
+ title="insertion mode: in row">in row</span>". (The
+ <span>current node</span> will be a <code>tr</code> element at
+ this point.)</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is one of: "caption", "col",
- "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
- <dd>
+ <dt>A start tag whose tag name is one of: "caption", "col",
+ "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does
- <em>not</em> <span title="has an element in table scope">have
- a <code>td</code> or <code>th</code> element in table
- scope</span>, then this is a <span>parse error</span>; ignore
- the token. (<span>fragment case</span>)</p>
+ <p>If the <span>stack of open elements</span> does
+ <em>not</em> <span title="has an element in table scope">have
+ a <code>td</code> or <code>th</code> element in table
+ scope</span>, then this is a <span>parse error</span>; ignore
+ the token. (<span>fragment case</span>)</p>
- <p>Otherwise, <span>close the cell</span> (see below) and
- reprocess the current token.</p>
+ <p>Otherwise, <span>close the cell</span> (see below) and
+ reprocess the current token.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "body", "caption",
- "col", "colgroup", "html"</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>An end tag whose tag name is one of: "body", "caption",
+ "col", "colgroup", "html"</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>An end tag whose tag name is one of: "table", "tbody",
- "tfoot", "thead", "tr"</dt>
- <dd>
+ <dt>An end tag whose tag name is one of: "table", "tbody",
+ "tfoot", "thead", "tr"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as that of the token
- (which can only happen for "tbody", "tfoot" and "thead", or,
- in the <span>fragment case</span>), then this is a <span>parse
- error</span> and the token must be ignored.</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as that of the token
+ (which can only happen for "tbody", "tfoot" and "thead", or,
+ in the <span>fragment case</span>), then this is a <span>parse
+ error</span> and the token must be ignored.</p>
- <p>Otherwise, <span>close the cell</span> (see below) and
- reprocess the current token.</p>
+ <p>Otherwise, <span>close the cell</span> (see below) and
+ reprocess the current token.</p>
- </dd>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> was
- "<span title="insertion mode: in body">in body</span>".</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> was
+ "<span title="insertion mode: in body">in body</span>".</p>
+ </dd>
- </dl>
+ </dl>
- <p>Where the steps above say to <dfn>close the cell</dfn>, they
- mean to run the following algorithm:</p>
+ <p>Where the steps above say to <dfn>close the cell</dfn>, they
+ mean to run the following algorithm:</p>
- <ol>
+ <ol>
- <li><p>If the <span>stack of open elements</span> <span
- title="has an element in table scope">has a <code>td</code>
- element in table scope</span>, then act as if an end tag token
- with the tag name "td" had been seen.</p></li>
+ <li><p>If the <span>stack of open elements</span> <span
+ title="has an element in table scope">has a <code>td</code>
+ element in table scope</span>, then act as if an end tag token
+ with the tag name "td" had been seen.</p></li>
- <li><p>Otherwise, the <span>stack of open elements</span> will
- <span title="has an element in table scope">have a
- <code>th</code> element in table scope</span>; act as if an end
- tag token with the tag name "th" had been seen.</p></li>
+ <li><p>Otherwise, the <span>stack of open elements</span> will
+ <span title="has an element in table scope">have a
+ <code>th</code> element in table scope</span>; act as if an end
+ tag token with the tag name "th" had been seen.</p></li>
- </ol>
+ </ol>
- <p class="note">The <span>stack of open elements</span> cannot
- have both a <code>td</code> and a <code>th</code> element <span
- title="has an element in table scope">in table scope</span> at
- the same time, nor can it have neither when the <span>insertion
- mode</span> is "<span title="insertion mode: in cell">in
- cell</span>".</p>
+ <p class="note">The <span>stack of open elements</span> cannot
+ have both a <code>td</code> and a <code>th</code> element <span
+ title="has an element in table scope">in table scope</span> at
+ the same time, nor can it have neither when the <span>insertion
+ mode</span> is "<span title="insertion mode: in cell">in
+ cell</span>".</p>
- <h6 id="parsing-main-inselect">The <dfn title="insertion mode: in select">in select</dfn> insertion mode</h6>
+ <h6 id="parsing-main-inselect">The <dfn title="insertion mode: in select">in select</dfn> insertion mode</h6>
- <p>Handle the token as follows:</p>
+ <p>Handle the token as follows:</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token</dt>
- <dd>
- <p><span title="append a character">Append the token's
- character</span> to the <span>current node</span>.</p>
- </dd>
+ <dt>A character token</dt>
+ <dd>
+ <p><span title="append a character">Append the token's
+ character</span> to the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is "option"</dt>
- <dd>
+ <dt>A start tag whose tag name is "option"</dt>
+ <dd>
- <p>If the <span>current node</span> is an <code>option</code>
- element, act as if an end tag with the tag name "option" had
- been seen.</p>
+ <p>If the <span>current node</span> is an <code>option</code>
+ element, act as if an end tag with the tag name "option" had
+ been seen.</p>
- <p><span>Insert an HTML element</span> for the token.</p>
+ <p><span>Insert an HTML element</span> for the token.</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "optgroup"</dt>
- <dd>
+ <dt>A start tag whose tag name is "optgroup"</dt>
+ <dd>
- <p>If the <span>current node</span> is an <code>option</code>
- element, act as if an end tag with the tag name "option" had
- been seen.</p>
+ <p>If the <span>current node</span> is an <code>option</code>
+ element, act as if an end tag with the tag name "option" had
+ been seen.</p>
- <p>If the <span>current node</span> is an
- <code>optgroup</code> element, act as if an end tag with the
- tag name "optgroup" had been seen.</p>
+ <p>If the <span>current node</span> is an
+ <code>optgroup</code> element, act as if an end tag with the
+ tag name "optgroup" had been seen.</p>
- <p><span>Insert an HTML element</span> for the token.</p>
+ <p><span>Insert an HTML element</span> for the token.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "optgroup"</dt>
- <dd>
+ <dt>An end tag whose tag name is "optgroup"</dt>
+ <dd>
- <p>First, if the <span>current node</span> is an
- <code>option</code> element, and the node immediately before
- it in the <span>stack of open elements</span> is an
- <code>optgroup</code> element, then act as if an end tag with
- the tag name "option" had been seen.</p>
+ <p>First, if the <span>current node</span> is an
+ <code>option</code> element, and the node immediately before
+ it in the <span>stack of open elements</span> is an
+ <code>optgroup</code> element, then act as if an end tag with
+ the tag name "option" had been seen.</p>
- <p>If the <span>current node</span> is an
- <code>optgroup</code> element, then pop that node from the
- <span>stack of open elements</span>. Otherwise, this is a
- <span>parse error</span>, ignore the token.</p>
+ <p>If the <span>current node</span> is an
+ <code>optgroup</code> element, then pop that node from the
+ <span>stack of open elements</span>. Otherwise, this is a
+ <span>parse error</span>, ignore the token.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "option"</dt>
- <dd>
+ <dt>An end tag whose tag name is "option"</dt>
+ <dd>
- <p>If the <span>current node</span> is an <code>option</code>
- element, then pop that node from the <span>stack of open
- elements</span>. Otherwise, this is a <span>parse
- error</span>, ignore the token.</p>
+ <p>If the <span>current node</span> is an <code>option</code>
+ element, then pop that node from the <span>stack of open
+ elements</span>. Otherwise, this is a <span>parse
+ error</span>, ignore the token.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is "select"</dt>
- <dd>
+ <dt>An end tag whose tag name is "select"</dt>
+ <dd>
- <p>If the <span>stack of open elements</span> does not <span
- title="has an element in table scope">have an element in table
- scope</span> with the same tag name as the token, this is a
- <span>parse error</span>. Ignore the token. (<span>fragment
- case</span>)</p>
+ <p>If the <span>stack of open elements</span> does not <span
+ title="has an element in table scope">have an element in table
+ scope</span> with the same tag name as the token, this is a
+ <span>parse error</span>. Ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Otherwise:</p>
+ <p>Otherwise:</p>
- <p>Pop elements from the <span>stack of open elements</span>
- until a <code>select</code> element has been popped from the
- stack.</p>
+ <p>Pop elements from the <span>stack of open elements</span>
+ until a <code>select</code> element has been popped from the
+ stack.</p>
- <p><span>Reset the insertion mode appropriately</span>.</p>
+ <p><span>Reset the insertion mode appropriately</span>.</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "select"</dt>
- <dd>
+ <dt>A start tag whose tag name is "select"</dt>
+ <dd>
- <p><span>Parse error</span>. Act as if the token had been
- an end tag with the tag name "select" instead.</p>
+ <p><span>Parse error</span>. Act as if the token had been
+ an end tag with the tag name "select" instead.</p>
- </dd>
+ </dd>
- <dt>An end tag whose tag name is one of: "caption", "table",
- "tbody", "tfoot", "thead", "tr", "td", "th"</dt>
- <dd>
+ <dt>An end tag whose tag name is one of: "caption", "table",
+ "tbody", "tfoot", "thead", "tr", "td", "th"</dt>
+ <dd>
- <p><span>Parse error</span>.</p>
+ <p><span>Parse error</span>.</p>
- <p>If the <span>stack of open elements</span> <span>has an
- element in table scope</span> with the same tag name as that
- of the token, then act as if an end tag with the tag name
- "select" had been seen, and reprocess the token. Otherwise,
- ignore the token.</p>
+ <p>If the <span>stack of open elements</span> <span>has an
+ element in table scope</span> with the same tag name as that
+ of the token, then act as if an end tag with the tag name
+ "select" had been seen, and reprocess the token. Otherwise,
+ ignore the token.</p>
- </dd>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-afterbody">The <dfn title="insertion mode: after body">after body</dfn> insertion mode</h6>
+ <h6 id="parsing-main-afterbody">The <dfn title="insertion mode: after body">after body</dfn> insertion mode</h6>
- <p>Handle the token as follows:</p>
+ <p>Handle the token as follows:</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p>Process the token as it would be processed if the
- <span>insertion mode</span> was "<span title="insertion mode:
- in body">in body</span>".</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p>Process the token as it would be processed if the
+ <span>insertion mode</span> was "<span title="insertion mode:
+ in body">in body</span>".</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the first element in
- the <span>stack of open elements</span> (the <code>html</code>
- element), with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the first element in
+ the <span>stack of open elements</span> (the <code>html</code>
+ element), with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>An end tag whose tag name is "html"</dt>
- <dd>
+ <dt>An end tag whose tag name is "html"</dt>
+ <dd>
- <p>If the parser was originally created as part of the
- <span>HTML fragment parsing algorithm</span>, this is a
- <span>parse error</span>; ignore the token. (The element will
- be an <code>html</code> element in this case.)
- (<span>fragment case</span>)</p>
+ <p>If the parser was originally created as part of the
+ <span>HTML fragment parsing algorithm</span>, this is a
+ <span>parse error</span>; ignore the token. (The element will
+ be an <code>html</code> element in this case.)
+ (<span>fragment case</span>)</p>
- <p>Otherwise, switch to <span>the trailing end
- phase</span>.</p>
+ <p>Otherwise, switch to <span>the trailing end
+ phase</span>.</p>
- </dd>
+ </dd>
- <dt>Anything else</dt>
- <dd>
+ <dt>Anything else</dt>
+ <dd>
- <p><span>Parse error</span>. Set the <span>insertion
- mode</span> to "<span title="insertion mode: in body">in
- body</span>" and reprocess the token.</p>
+ <p><span>Parse error</span>. Set the <span>insertion
+ mode</span> to "<span title="insertion mode: in body">in
+ body</span>" and reprocess the token.</p>
- </dd>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-inframeset">The <dfn title="insertion mode: in frameset">in frameset</dfn> insertion mode</h6>
+ <h6 id="parsing-main-inframeset">The <dfn title="insertion mode: in frameset">in frameset</dfn> insertion mode</h6>
- <p>Handle the token as follows:</p>
+ <p>Handle the token as follows:</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p><span title="append a character">Append the character</span> to
- the <span>current node</span>.</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p><span title="append a character">Append the character</span> to
+ the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>A start tag whose tag name is "frameset"</dt>
- <dd>
- <p><span title="Insert an HTML element">Insert a
- <code>frameset</code> element</span> for the token.</p>
- </dd>
+ <dt>A start tag whose tag name is "frameset"</dt>
+ <dd>
+ <p><span title="Insert an HTML element">Insert a
+ <code>frameset</code> element</span> for the token.</p>
+ </dd>
- <dt>An end tag whose tag name is "frameset"</dt>
- <dd>
+ <dt>An end tag whose tag name is "frameset"</dt>
+ <dd>
- <p>If the <span>current node</span> is the root
- <code>html</code> element, then this is a <span>parse
- error</span>; ignore the token. (<span>fragment
- case</span>)</p>
+ <p>If the <span>current node</span> is the root
+ <code>html</code> element, then this is a <span>parse
+ error</span>; ignore the token. (<span>fragment
+ case</span>)</p>
- <p>Otherwise, pop the <span>current node</span> from the
- <span>stack of open elements</span>.</p>
+ <p>Otherwise, pop the <span>current node</span> from the
+ <span>stack of open elements</span>.</p>
- <p>If the parser was <em>not</em> originally created as part
- of the <span>HTML fragment parsing algorithm</span>
- (<span>fragment case</span>), and the <span>current
- node</span> is no longer a <code>frameset</code> element, then
- change the <span>insertion mode</span> to "<span
- title="insertion mode: after frameset">after
- frameset</span>".</p>
+ <p>If the parser was <em>not</em> originally created as part
+ of the <span>HTML fragment parsing algorithm</span>
+ (<span>fragment case</span>), and the <span>current
+ node</span> is no longer a <code>frameset</code> element, then
+ change the <span>insertion mode</span> to "<span
+ title="insertion mode: after frameset">after
+ frameset</span>".</p>
- </dd>
+ </dd>
- <dt>A start tag whose tag name is "frame"</dt>
- <dd>
- <p><span>Insert an HTML element</span> for the token.
- Immediately pop the <span>current node</span> off the
- <span>stack of open elements</span>.</p>
- </dd>
+ <dt>A start tag whose tag name is "frame"</dt>
+ <dd>
+ <p><span>Insert an HTML element</span> for the token.
+ Immediately pop the <span>current node</span> off the
+ <span>stack of open elements</span>.</p>
+ </dd>
- <dt>A start tag whose tag name is "noframes"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "noframes"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in body</span>".</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- </dl>
+ </dl>
- <h6 id="parsing-main-afterframeset">The <dfn title="insertion mode: after frameset">after frameset</dfn> insertion mode</h6>
+ <h6 id="parsing-main-afterframeset">The <dfn title="insertion mode: after frameset">after frameset</dfn> insertion mode</h6>
- <p>Handle the token as follows:</p>
+ <p>Handle the token as follows:</p>
- <dl class="switch">
+ <dl class="switch">
- <dt>An end-of-file token</dt>
- <dd>
- <p><span>Stop parsing, with prejudice.</span></p>
- </dd>
+ <dt>An end-of-file token</dt>
+ <dd>
+ <p><span>Stop parsing, with prejudice.</span></p>
+ </dd>
- <dt>A character token that is one of one of U+0009
- CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
- TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
- or U+0020 SPACE</dt>
- <dd>
- <p><span title="append a character">Append the character</span> to
- the <span>current node</span>.</p>
- </dd>
+ <dt>A character token that is one of one of U+0009
+ CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+ TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+ or U+0020 SPACE</dt>
+ <dd>
+ <p><span title="append a character">Append the character</span> to
+ the <span>current node</span>.</p>
+ </dd>
- <dt>A comment token</dt>
- <dd>
- <p>Append a <code>Comment</code> node to the <span>current
- node</span> with the <code title="">data</code> attribute set to
- the data given in the comment token.</p>
- </dd>
+ <dt>A comment token</dt>
+ <dd>
+ <p>Append a <code>Comment</code> node to the <span>current
+ node</span> with the <code title="">data</code> attribute set to
+ the data given in the comment token.</p>
+ </dd>
- <dt>A DOCTYPE token</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>A DOCTYPE token</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- <dt>A start tag whose tag name is "html"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in
- body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "html"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in
+ body</span>".</p>
+ </dd>
- <dt>An end tag whose tag name is "html"</dt>
- <dd>
- <p>Switch to <span>the trailing end phase</span>.</p>
- </dd>
+ <dt>An end tag whose tag name is "html"</dt>
+ <dd>
+ <p>Switch to <span>the trailing end phase</span>.</p>
+ </dd>
- <dt>A start tag whose tag name is "noframes"</dt>
- <dd>
- <p>Process the token as if the <span>insertion mode</span> had
- been "<span title="insertion mode: in body">in body</span>".</p>
- </dd>
+ <dt>A start tag whose tag name is "noframes"</dt>
+ <dd>
+ <p>Process the token as if the <span>insertion mode</span> had
+ been "<span title="insertion mode: in body">in body</span>".</p>
+ </dd>
- <dt>Anything else</dt>
- <dd>
- <p><span>Parse error</span>. Ignore the token.</p>
- </dd>
+ <dt>Anything else</dt>
+ <dd>
+ <p><span>Parse error</span>. Ignore the token.</p>
+ </dd>
- </dl>
+ </dl>
<p class="big-issue">This doesn't handle UAs that don't support
frames, or that do support frames but want to show the NOFRAMES
More information about the Commit-Watchers
mailing list