The input to the tree construction stage is a sequence of tokens from
the tokenisation stage. The tree construction
stage is associated with a DOM Document object when a parser
is created. The "output" of this stage consists of dynamically modifying
or extending that document's DOM tree.
This specification does not define when an interactive user agent has to
render the Document so that it is available to the user, or
when it has to begin accepting user input.
When the steps below require the UA to insert a
character into a node, if that node has a child immediately before
where the character is to be inserted, and that child is a
Text node, then the character must be appended to that
Text node; otherwise, a new Text node whose data
is just that character must be inserted in the appropriate place.
DOM mutation events must not fire for changes
caused by the UA parsing the document. (Conceptually, the parser is not
mutating the DOM, it is constructing it.) This includes the parsing of any
content inserted using document.write() and document.writeln() calls.
[DOM3EVENTS]
Not all of the tag names mentioned below are conformant tag names in this specification; many are included to handle legacy content. They still form part of the algorithm that implementations are required to implement to claim conformance.
The algorithm described below places no limit on the depth of the DOM tree generated, or on the length of tag names, attribute names, attribute values, text nodes, etc. While implementators are encouraged to avoid arbitrary limits, it is recognised that practical concerns will likely force user agents to impose nesting depths.
As each token is emitted from the tokeniser, the user agent must process the token according to the rules given in the section corresponding to the current insertion mode.
Initially the insertion mode is "initial". It can change to "before html", "before head", "in head", "in head noscript", "after head", "in body", "in table", "in caption", "in column group", "in table body", "in row", "in cell", "in select", "in select in table", "after body", "in frameset", "after frameset", "after after body", and "after after frameset" during the course of the parsing, as described below. It affects how certain tokens are processed.
Four of these modes, namely "in head", "in body", "in table", and "in select", are special, in that the other modes defer to them at various times. When the algorithm below says that the user agent is to do something "using the rules for the m insertion mode", where m is one of these modes, the user agent must use the rules described under that insertion mode's section, but must leave the insertion mode unchanged (unless the rules in that section themselves switch the insertion mode).
In addition to the insertion mode, the tree
construction stage has several pieces of state: a stack
of open elements, a list of active formatting
elements, a head element
pointer, and a form
element pointer.
Initially the stack of open elements is empty. The stack grows downwards; the topmost node on the stack is the first one added to the stack, and the bottommost node of the stack is the most recently added node in the stack (notwithstanding when the stack is manipulated in a random access fashion as part of the handling for misnested tags).
The "before
html" insertion mode creates the html root element node, which is then added to the
stack.
In the fragment case, the stack
of open elements is initialised to contain an html element that is created as part of that
algorithm. (The fragment case skips the "before html" insertion mode.)
The html node, however it is created,
is the topmost node of the stack. It never gets popped off the stack.
The current node is the bottommost node in this stack.
The current table is the last table element in the stack of
open elements, if there is one. If there is no table element in the stack of
open elements (fragment case), then the current table is the first element in the stack of open elements (the html element).
Elements in the stack fall into the following categories:
The following HTML elements have varying levels of special parsing
rules: address, area, base,
basefont, bgsound, blockquote, body, br,
center, col, colgroup, dd,
dir, div, dl, dt, embed, fieldset,
form, frame, frameset, h1, h2, h3, h4, h5, h6, head, hr,
iframe,
image,
img, input,
isindex, li, link, listing, menu, meta,
noembed, noframes, noscript, ol,
optgroup, option, p, param,
plaintext, pre, script, select,
spacer, style, tbody, textarea, tfoot, thead, title, tr,
ul, and wbr.
The following HTML elements introduce new scopes for various parts of the
parsing: applet, button, caption, html, marquee, object, table, td and
th.
The following HTML elements are those that end up in the list of active formatting elements: a, b,
big, em, font, i,
nobr, s, small, strike, strong, tt, and u.
All other elements found while parsing an HTML document.
Still need to add these new elements to the lists:
event-source, section, nav,
article, aside, header,
footer, datagrid, command
The stack of open elements is said to have an element in scope or have an element in table scope when the following algorithm terminates in a match state:
Initialise node to be the current node (the bottommost node of the stack).
If node is the target node, terminate in a match state.
Otherwise, if node is a table element, terminate in a failure state.
Otherwise, if the algorithm is the "has an element in scope" variant (rather than the "has an element in table scope" variant), and node is one of the following, terminate in a failure state:
Otherwise, if node is an html element, terminate in a failure state.
(This can only happen if the node is the topmost
node of the stack of open elements, and prevents
the next step from being invoked if there are no more elements in the
stack.)
Otherwise, set node to the previous entry in the stack of open elements and return to step 2. (This will never fail, since the loop will always terminate in the previous step if the top of the stack is reached.)
Nothing happens if at any time any of the elements in the stack of open elements are moved to a new location in,
or removed from, the Document tree. In particular, the stack
is not changed in this situation. This can cause, amongst other strange
effects, content to be appended to nodes that are no longer in the DOM.
In some cases (namely, when closing misnested formatting elements), the stack is manipulated in a random-access fashion.
Initially the list of active formatting elements is empty. It is used to handle mis-nested formatting element tags.
The list contains elements in the formatting
category, and scope markers. The scope markers are inserted when entering
applet elements, buttons, object elements, marquees, table cells, and
table captions, and are used to prevent formatting from "leaking" into
applet elements, buttons, object elements, marquees, and tables.
When the steps below require the UA to reconstruct the active formatting elements, the UA must perform the following steps:
This has the effect of reopening all the formatting elements that were opened in the current body, cell, or caption (whichever is youngest) that haven't been explicitly closed.
The way this specification is written, the list of active formatting elements always consists of elements in chronological order with the least recently added element first and the most recently added element last (except for while steps 8 to 11 of the above algorithm are being executed, of course).
When the steps below require the UA to clear the list of active formatting elements up to the last marker, the UA must perform the following steps:
When the steps below require the UA to create an element for a token, the UA must
create a node implementing the interface appropriate for the element type
corresponding to the tag name of the token (as given in the section of
this specification that defines that element, e.g. for an a element it would be the HTMLAnchorElement interface), with
the tag name being the name of that element, with the node being in the HTML namespace, and with the attributes on the
node being those given in the given token.
When the steps below require the UA to insert an HTML element for a token, the UA must first create an element for the token, and then append this node to the current node, and push it onto the stack of open elements so that it is the new current node.
The steps below may also require that the UA insert an HTML element in a particular place, in which case the UA must create an element for the token and then insert or append the new node in the location specified. (This happens in particular during the parsing of tables with invalid content.)
The interface appropriate for an element that is not defined in this
specification is HTMLElement.
The generic CDATA parsing algorithm and the generic RCDATA parsing algorithm consist of the following steps. These algorithms are always invoked in response to a start tag token.
Append the new element to the current node.
If the algorithm that was invoked is the generic CDATA parsing algorithm, switch the tokeniser's content model flag to the CDATA state; otherwise the algorithm invoked was the generic RCDATA parsing algorithm, switch the tokeniser's content model flag to the RCDATA state.
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.
If this process resulted in a collection of character tokens, append a
single Text node, whose contents is the concatenation of
all those tokens' characters, to the new element node.
The tokeniser's content model flag will have switched back to the PCDATA state.
If the next token is an end tag token with the same tag name as the start tag token, ignore it. Otherwise, it's an end-of-file token, and this is a parse error.
When the steps below require the UA to generate implied
end tags, then, while the current node is a
dd element, a dt element, an li
element, or a p element, the UA must pop the
current node off the stack of
open elements.
If a step requires the UA to generate implied end tags but lists an element to exclude from the process, then the UA must perform the above steps as if that element was not in the above list.
Initially the head element
pointer and the form
element pointer are both null.
Once a head element has been parsed
(whether implicitly or explicitly) the head element pointer gets set to point to this node.
The form element
pointer points to the last form element that was opened
and whose end tag has not yet been seen. It is used to make form controls
associate with forms in the face of dramatically bad markup, for
historical reasons.
When the steps below require the UA to reset the insertion mode appropriately, it means the UA must follow these steps:
td element nor a th
element, then set node to the context element. (fragment case)
select element, then
switch the insertion mode to "in select" and
abort these steps. (fragment case)
td or
th element, then switch the insertion mode to "in cell" and abort these steps.
tr
element, then switch the insertion mode to "in row" and abort these
steps.
tbody, thead,
or tfoot element, then switch the insertion mode to "in table body" and abort these
steps.
caption element, then switch the insertion mode to "in caption" and abort these steps.
colgroup element, then switch the insertion mode to "in column group" and abort
these steps. (fragment case)
table element, then switch the insertion mode to "in table" and abort these steps.
head
element, then switch the insertion mode to "in body" ("in body"! not
"in head"!)
and abort these steps. (fragment case)body element, then switch the insertion mode to "in body" and abort these steps.
frameset element, then
switch the insertion mode to "in frameset"
and abort these steps. (fragment case)
html element, then: if the head element pointer is
null, switch the insertion mode to "before head",
otherwise, switch the insertion mode to "after head". In
either case, abort these steps. (fragment case)When the insertion mode is "initial", tokens must be handled as follows:
Ignore the token.
Append a Comment node to the Document object
with the data attribute set to the data given in
the comment token.
If the DOCTYPE token's name does not
case-insensitively match the string "HTML", or if
the token's public identifier is not missing, or if the token's system
identifier is not missing, then there is a parse
error. Conformance checkers may, instead of reporting this error,
switch to a conformance checking mode for another language (e.g. based
on the DOCTYPE token a conformance checker could recognise that the
document is an HTML4-era document, and defer to an HTML4 conformance
checker.)
Append a DocumentType node to the Document
node, with the name attribute set to the name
given in the DOCTYPE token; the publicId attribute
set to the public identifier given in the DOCTYPE token, or the empty
string if the public identifier was not set; the systemId attribute set to the system identifier given in
the DOCTYPE token, or the empty string if the system identifier was not
set; and the other attributes specific to DocumentType
objects set to null and empty lists as appropriate. Associate the
DocumentType node with the Document object so
that it is returned as the value of the doctype
attribute of the Document object.
Then, if the DOCTYPE token matches one of the conditions in the following list, then set the document to quirks mode:
HTML".
+//Silmaril//dtd
html Pro v0r11 19970101//EN"
-//AdvaSoft
Ltd//DTD HTML 3.0 asWedit + extensions//EN"
-//AS//DTD HTML
3.0 asWedit + extensions//EN"
-//IETF//DTD HTML
2.0 Level 1//EN"
-//IETF//DTD HTML
2.0 Level 2//EN"
-//IETF//DTD HTML
2.0 Strict Level 1//EN"
-//IETF//DTD HTML
2.0 Strict Level 2//EN"
-//IETF//DTD HTML
2.0 Strict//EN"
-//IETF//DTD HTML
2.0//EN"
-//IETF//DTD HTML
2.1E//EN"
-//IETF//DTD HTML
3.0//EN"
-//IETF//DTD HTML
3.0//EN//"
-//IETF//DTD HTML
3.2 Final//EN"
-//IETF//DTD HTML
3.2//EN"
-//IETF//DTD HTML
3//EN"
-//IETF//DTD HTML
Level 0//EN"
-//IETF//DTD HTML
Level 0//EN//2.0"
-//IETF//DTD HTML
Level 1//EN"
-//IETF//DTD HTML
Level 1//EN//2.0"
-//IETF//DTD HTML
Level 2//EN"
-//IETF//DTD HTML
Level 2//EN//2.0"
-//IETF//DTD HTML
Level 3//EN"
-//IETF//DTD HTML
Level 3//EN//3.0"
-//IETF//DTD HTML
Strict Level 0//EN"
-//IETF//DTD HTML
Strict Level 0//EN//2.0"
-//IETF//DTD HTML
Strict Level 1//EN"
-//IETF//DTD HTML
Strict Level 1//EN//2.0"
-//IETF//DTD HTML
Strict Level 2//EN"
-//IETF//DTD HTML
Strict Level 2//EN//2.0"
-//IETF//DTD HTML
Strict Level 3//EN"
-//IETF//DTD HTML
Strict Level 3//EN//3.0"
-//IETF//DTD HTML
Strict//EN"
-//IETF//DTD HTML
Strict//EN//2.0"
-//IETF//DTD HTML
Strict//EN//3.0"
-//IETF//DTD
HTML//EN"
-//IETF//DTD
HTML//EN//2.0"
-//IETF//DTD
HTML//EN//3.0"
-//Metrius//DTD
Metrius Presentational//EN"
-//Microsoft//DTD
Internet Explorer 2.0 HTML Strict//EN"
-//Microsoft//DTD
Internet Explorer 2.0 HTML//EN"
-//Microsoft//DTD
Internet Explorer 2.0 Tables//EN"
-//Microsoft//DTD
Internet Explorer 3.0 HTML Strict//EN"
-//Microsoft//DTD
Internet Explorer 3.0 HTML//EN"
-//Microsoft//DTD
Internet Explorer 3.0 Tables//EN"
-//Netscape Comm.
Corp.//DTD HTML//EN"
-//Netscape Comm.
Corp.//DTD Strict HTML//EN"
-//O'Reilly and
Associates//DTD HTML 2.0//EN"
-//O'Reilly and
Associates//DTD HTML Extended 1.0//EN"
-//O'Reilly and
Associates//DTD HTML Extended Relaxed 1.0//EN"
-//SoftQuad
Software//DTD HoTMetaL PRO 6.0::19990601::extensions to HTML
4.0//EN"
-//SoftQuad//DTD
HoTMetaL PRO 4.0::19971010::extensions to HTML 4.0//EN"
-//Spyglass//DTD
HTML 2.0 Extended//EN"
-//SQ//DTD HTML
2.0 HoTMetaL + extensions//EN"
-//Sun
Microsystems Corp.//DTD HotJava HTML//EN"
-//Sun
Microsystems Corp.//DTD HotJava Strict HTML//EN"
-//W3C//DTD HTML 3
1995-03-24//EN"
-//W3C//DTD HTML
3.2 Draft//EN"
-//W3C//DTD HTML
3.2 Final//EN"
-//W3C//DTD HTML
3.2//EN"
-//W3C//DTD HTML
3.2S Draft//EN"
-//W3C//DTD HTML
4.0 Frameset//EN"
-//W3C//DTD HTML
4.0 Transitional//EN"
-//W3C//DTD HTML
Experimental 19960712//EN"
-//W3C//DTD HTML
Experimental 970421//EN"
-//W3C//DTD W3
HTML//EN"
-//W3O//DTD W3
HTML 3.0//EN"
-//W3O//DTD W3
HTML 3.0//EN//"
-//W3O//DTD W3
HTML Strict 3.0//EN//"
-//WebTechs//DTD
Mozilla HTML 2.0//EN"
-//WebTechs//DTD
Mozilla HTML//EN"
-/W3C/DTD HTML 4.0
Transitional/EN"
HTML"
http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"
-//W3C//DTD HTML 4.01 Frameset//EN"
-//W3C//DTD HTML 4.01 Transitional//EN"
Otherwise, if the DOCTYPE token matches one of the conditions in the following list, then set the document to limited quirks mode:
-//W3C//DTD XHTML
1.0 Frameset//EN"
-//W3C//DTD XHTML
1.0 Transitional//EN"
-//W3C//DTD HTML 4.01 Frameset//EN"
-//W3C//DTD HTML 4.01 Transitional//EN"
The name, system identifier, and public identifier strings must be compared to the values given in the lists above in a case-insensitive manner.
Then, switch the insertion mode to "before html".
Set the document to quirks mode.
Switch the insertion mode to "before html", then reprocess the current token.
When the insertion mode is "before html", tokens must be handled as follows:
Parse error. Ignore the token.
Append a Comment node to the Document object
with the data attribute set to the data given in
the comment token.
Ignore the token.
Create an element for the token. Append it to
the Document object. Put this element in the stack of open elements.
If the token has an attribute "manifest", then run the application cache selection algorithm with the value of that attribute as the manifest URI. Otherwise, run the application cache selection algorithm with no manifest.
Switch the insertion mode to "before head".
Create an HTMLElement node
with the tag name html, in the HTML namespace. Append it to the
Document object. Put this element in the stack of open elements.
Run the application cache selection algorithm with no manifest.
Switch the insertion mode to "before head", then reprocess the current token.
Should probably make end tags be ignored, so that "</head><!-- --><html>" puts the comment before the root node (or should we?)
The root element can end up being removed from the Document
object, e.g. by scripts; nothing in particular happens in such cases,
content continues being appended to the nodes as described in the next
section.
When the insertion mode is "before head", tokens must be handled as follows:
Ignore the token.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Create an element for the token.
Set the head element
pointer to this new element node.
Append the new element to the current node and push it onto the stack of open elements.
Switch the insertion mode to "in head".
Act as if a start tag token with the tag name "head" and no attributes had been seen, then reprocess the current token.
Parse error. Ignore the token.
Do we really want to ignore end tags here?
Act as if a start tag token with the tag name "head" and no attributes had been seen, then reprocess the current token.
This will result in an empty head element being generated, with the current
token being reprocessed in the "after head" insertion mode.
When the insertion mode is "in head", tokens must be handled as follows:
Insert the character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
If the element has a charset
attribute, and its value is a supported encoding, and the confidence is
currently tentative, then change the
encoding to the encoding given by the value of the charset
attribute.
Otherwise, if the element has a content attribute, and applying the algorithm for extracting an encoding from a
Content-Type to its value returns a supported encoding encoding, and the confidence is currently
tentative, then change the encoding to the
encoding encoding.
Follow the generic RCDATA parsing algorithm.
Follow the generic CDATA parsing algorithm.
Insert an HTML element for the token.
Switch the insertion mode to "in head noscript".
Create an element for the token.
Mark the element as being "parser-inserted". This ensures that, if the
script is external, any document.write() calls in the
script will execute in-line, instead of blowing the document away, as
would happen in most other cases.
Switch the tokeniser's content model flag to the CDATA state.
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.
If this process resulted in a collection of character tokens, append a
single Text node to the script element node whose contents is the
concatenation of all those tokens' characters.
The tokeniser's content model flag will have switched back to the PCDATA state.
If the next token is not an end tag token with the tag name "script",
then this is a parse error; mark the script element as "already
executed". Otherwise, the token is the script element's end tag, so ignore it.
If the parser was originally created for the HTML fragment parsing algorithm, then mark
the script element as "already executed", and skip the rest of the
processing described for this token (including the part below where "scripts that will execute as soon as the parser
resumes" are executed). (fragment case)
Marking the script
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 innerHTML
aren't executed.
Let the old insertion point have the same value as the current insertion point. Let the insertion point be just before the next input character.
Append the new element to the current node. Special processing occurs when
a script element is inserted into a document that might
cause some script to execute, which might cause new characters
to be inserted into the tokeniser.
Let the insertion point have the value of the old insertion point. (In other words, restore the insertion point to the value it had before the previous paragraph. This value might be the "undefined" value.)
At this stage, if there is a script that will execute as soon as the parser resumes, then:
document.write():
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.)
Follow these steps:
Let the script be the script that will execute as soon as the parser resumes. There is no longer a script that will execute as soon as the parser resumes.
Pause until the script has completed loading.
Let the insertion point be just before the next input character.
Let the insertion point be undefined again.
If there is once again a script that will execute as soon as the parser resumes, then repeat these steps from step 1.
Pop the current node (which will be the
head element) off the stack of open elements.
Switch the insertion mode to "after head".
Act as described in the "anything else" entry below.
Parse error. Ignore the token.
Act as if an end tag token with the tag name "head" had been seen, and reprocess the current token.
In certain UAs, some elements don't trigger the "in body" mode straight away, but instead get put into the head. Do we want to copy that?
When the insertion mode is "in head noscript", tokens must be handled as follows:
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Pop the current node (which will be a noscript element) from the stack of open elements; the new current node will be a head element.
Switch the insertion mode to "in head".
Process the token using the rules for the "in head" insertion mode.
Act as described in the "anything else" entry below.
Parse error. Ignore the token.
Parse error. Act as if an end tag with the tag name "noscript" had been seen and reprocess the current token.
When the insertion mode is "after head", tokens must be handled as follows:
Insert the character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token.
Switch the insertion mode to "in body".
Insert an HTML element for the token.
Switch the insertion mode to "in frameset".
Push the node pointed to by the head element pointer onto the stack
of open elements.
Process the token using the rules for the "in head" insertion mode.
Pop the current node (which will be the node
pointed to by the head
element pointer) off the stack of open
elements.
Act as if a start tag token with the tag name "body" and no attributes had been seen, and then reprocess the current token.
When the insertion mode is "in body", tokens must be handled as follows:
Reconstruct the active formatting elements, if any.
Insert the token's character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Parse error. For each attribute on the token, check to see if the attribute is already present on the top element of the stack of open elements. If it is not, add the attribute and its corresponding value to that element.
Process the token using the rules for the "in head" insertion mode.
If the second element on the stack of open
elements is not a body element,
or, if the stack of open elements has only one node
on it, then ignore the token. (fragment case)
Otherwise, for each attribute on the token, check to see if the
attribute is already present on the body element (the second element) on the stack of open elements. If it is not, add the
attribute and its corresponding value to that element.
If there is a node in the stack of open elements
that is not either a dd element, a
dt element, an li element, a p
element, a tbody element, a td element, a tfoot element, a th element, a thead element, a tr element, the body element, or the html element, then this is a parse error.
If the stack of open elements does not have a body
element in scope, this is a parse error;
ignore the token.
Otherwise, if there is a node in the stack of open
elements that is not either a dd
element, a dt element, an li element, a p
element, a tbody element, a td element, a tfoot element, a th element, a thead element, a tr element, the body element, or the html element, then this is a parse error.
Switch the insertion mode to "after body". Otherwise, ignore the token.
Act as if an end tag with tag name "body" had been seen, then, if that token wasn't ignored, reprocess the current token.
The fake end tag token here can only be ignored in the fragment case.
This doesn't match browsers.
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Insert an HTML element for the token.
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Insert an HTML element for the token.
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
pre blocks are ignored as an authoring
convenience.)
If the form element
pointer is not null, ignore the token with a parse
error.
Otherwise:
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Insert an HTML element for the token, and set
the form element pointer to point to the element
created.
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Run the following algorithm:
Initialise node to be the current node (the bottommost node of the stack).
If node is an li
element, then pop all the nodes from the current
node up to node, including node, then stop this algorithm. If more than one node
is popped, then this is a parse error.
If node is not in the formatting category, and is not in the phrasing category, and is not an address or div element, then stop this algorithm.
Otherwise, set node to the previous entry in the stack of open elements and return to step 2.
Finally, insert an HTML element for the token.
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Run the following algorithm:
Initialise node to be the current node (the bottommost node of the stack).
If node is a dd
or dt element, then pop all the nodes
from the current node up to node, including node, then stop
this algorithm. If more than one node is popped, then this is a parse error.
If node is not in the formatting category, and is not in the phrasing category, and is not an address or div element, then stop this algorithm.
Otherwise, set node to the previous entry in the stack of open elements and return to step 2.
Finally, insert an HTML element for the token.
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Insert an HTML element for the token.
Switch the content model flag to the PLAINTEXT state.
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 content model flag out of the PLAINTEXT state.
If the stack of open elements does not have an element in scope with the same tag name as that of the token, then this is a parse error.
Otherwise, run these steps:
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
Set the form element
pointer to null.
If the stack of open elements does not have an element in scope with the same tag name as that of the token, then this is a parse error.
Otherwise, run these steps:
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
If the current node is not a p element, then this is a parse
error.
If the stack of open elements has a p element in
scope, then pop elements from this stack until the stack no longer
has a p
element in scope.
Otherwise, act as if a start tag with the tag name p had been seen, then reprocess the current token.
If the stack of open elements does not have an element in scope with the same tag name as that of the token, then this is a parse error.
Otherwise, run these steps:
Generate implied end tags, except for elements with the same tag name as the token.
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
If the stack of open elements does not have an element in scope whose tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then this is a parse error.
Otherwise, run these steps:
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element whose tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6" has been popped from the stack.
If the list of active formatting elements 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 parse error; act as if an end tag with the tag name "a" had been seen, then remove that element from the list of active formatting elements and the stack of open elements if the end tag didn't already remove it (it might not have if the element is not in table scope).
In the non-conforming stream
<a href="a">a<table><a href="b">b</table>x,
the first a 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 a element is not in table scope (meaning that a
regular </a> end tag at the start of the table wouldn't
close the outer a element).
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token. Add that element to the list of active formatting elements.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token. Add that element to the list of active formatting elements.
Reconstruct the active formatting elements, if any.
If the stack of open elements has a nobr element in
scope, then this is a parse error. Act as if
an end tag with the tag name nobr had been seen, then once
again reconstruct the active formatting
elements, if any.
Insert an HTML element for the token. Add that element to the list of active formatting elements.
Follow these steps:
Let the formatting element be the last element in the list of active formatting elements that:
If there is no such node, or, if that node is also in the stack of open elements but the element is not in scope, then this is a parse error. Abort these steps. The token is ignored.
Otherwise, if there is such a node, but that node is not in the stack of open elements, then this is a parse error; remove the element from the list, and abort these steps.
Otherwise, there is a formatting element and that element is in the stack and is in scope. If the element is not the current node, this is a parse error. In any case, proceed with the algorithm as written in the following steps.
Let the furthest block be the topmost node in the stack of open elements that is lower in the stack than the formatting element, and is not an element in the phrasing or formatting categories. There might not be one.
If there is no furthest block, then the UA must skip the subsequent steps and instead just pop all the nodes from the bottom of the stack of open elements, from the current node up to and including the formatting element, and remove the formatting element from the list of active formatting elements.
Let the common ancestor be the element immediately above the formatting element in the stack of open elements.
If the furthest block has a parent node, then remove the furthest block from its parent node.
Let a bookmark note the position of the formatting element in the list of active formatting elements relative to the elements on either side of it in the list.
Let node and last node be the furthest block. Follow these steps:
If the common ancestor node is a table, tbody, tfoot, thead, or tr
element, then, insert whatever last node ended up
being in the previous step into the foster parent
element. If the foster parent
element is the parent element of the last table element in the stack
of open elements, then last node must be
inserted immediately before the last table element in the stack
of open elements in the foster parent
element; otherwise, last node must be
appended to the foster parent
element.
Otherwise, append whatever last node ended up being in the previous step to the common ancestor node, first removing it from its previous parent node if any.
Perform a shallow clone of the formatting element.
Take all of the child nodes of the furthest block and append them to the clone created in the last step.
Append that clone to the furthest block.
Remove the formatting element from the list of active formatting elements, and insert the clone into the list of active formatting elements at the position of the aforementioned bookmark.
Remove the formatting element from the stack of open elements, and insert the clone into the stack of open elements immediately below the position of the furthest block in that stack.
Jump back to step 1 in this series of steps.
The way these steps are defined, only elements in the formatting category ever get cloned by this algorithm.
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").
If the stack of open elements has a button element in
scope, then this is a parse error; act as if
an end tag with the tag name "button" had been seen, then reprocess the
token.
Otherwise:
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
If the form element
pointer is not null, then associate
the button element with the form element
pointed to by the form
element pointer.
Insert a marker at the end of the list of active formatting elements.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
Insert a marker at the end of the list of active formatting elements.
If the stack of open elements does not have an element in scope with the same tag name as that of the token, then this is a parse error.
Otherwise, run these steps:
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
Reconstruct the active formatting elements, if any.
Follow the generic CDATA parsing algorithm.
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Insert an HTML element for the token.
Switch the insertion mode to "in table".
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
If the stack of open elements has a p element in
scope, then act as if an end tag with the tag name p had been seen.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Parse error. Change the token's tag name to "img" and reprocess it. (Don't ask.)
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
If the form element
pointer is not null, then associate
the input element with the form element
pointed to by the form
element pointer.
Pop that input element off the stack of
open elements.
If the form element
pointer is not null, then ignore the token.
Otherwise:
Act as if a start tag token with the tag name "form" had been seen.
If the token has an attribute called "action", set the action attribute on the resulting
form element to the value of the "action" attribute of the
token.
Act as if a start tag token with the tag name "hr" had been seen.
Act as if a start tag token with the tag name "p" had been seen.
Act as if a start tag token with the tag name "label" had been seen.
Act as if a stream of character tokens had been seen (see below for what they should say).
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 name
attribute of the resulting input element to the value
"isindex".
Act as if a stream of character tokens had been seen (see below for what they should say).
Act as if an end tag token with the tag name "label" had been seen.
Act as if an end tag token with the tag name "p" had been seen.
Act as if a start tag token with the tag name "hr" had been seen.
Act as if an end tag token with the tag name "form" had been seen.
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
input element, express the equivalent of "This is a
searchable index. Insert your search keywords here: (input field)" in
the user's preferred language.
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.
Create an element for the token.
If the form element
pointer is not null, then associate
the textarea element with the form element
pointed to by the form
element pointer.
Append the new element to the current node.
Switch the tokeniser's content model flag to the RCDATA state.
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
textarea elements are ignored as an authoring convenience.)
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.
If this process resulted in a collection of character tokens, append a
single Text node, whose contents is the concatenation of
all those tokens' characters, to the new element node.
The tokeniser's content model flag will have switched back to the PCDATA state.
If the next token is an end tag token with the tag name "textarea", ignore it. Otherwise, this is a parse error.
Follow the generic CDATA parsing algorithm.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
If the form element
pointer is not null, then associate
the select element with the form element
pointed to by the form
element pointer.
If the insertion mode is one of in table", "in caption", "in column group", "in table body", "in row", or "in cell", then switch the insertion mode to "in select in table". Otherwise, switch the insertion mode to "in select".
Parse error. Act as if a start tag token with the tag name "br" had been seen. Ignore the end tag token.
Parse error. Ignore the token.
Work in progress!
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
This element will be a phrasing element.
Run the following algorithm:
Initialise node to be the current node (the bottommost node of the stack).
If node has the same tag name as the end tag token, then:
If the tag name of the end tag token does not match the tag name of the current node, this is a parse error.
Pop all the nodes from the current node up to node, including node, then stop this algorithm.
Otherwise, if node is in neither the formatting category nor the phrasing category, then this is a parse error. Stop this algorithm. The end tag token is ignored.
Set node to the previous entry in the stack of open elements.
Return to step 2.
When the insertion mode is "in table", tokens must be handled as follows:
If the current table is tainted, then act as described in the "anything else" entry below.
Otherwise, insert the character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Clear the stack back to a table context. (See below.)
Insert a marker at the end of the list of active formatting elements.
Insert an HTML element for the token, then switch the insertion mode to "in caption".
Clear the stack back to a table context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in column group".
Act as if a start tag token with the tag name "colgroup" had been seen, then reprocess the current token.
Clear the stack back to a table context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in table body".
Act as if a start tag token with the tag name "tbody" had been seen, then reprocess the current token.
Parse error. 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.
The fake end tag token here can only be ignored in the fragment case.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Pop elements from this stack until a table element has been popped from the stack.
Parse error. Ignore the token.
If the current table is tainted then act as described in the "anything else" entry below.
Otherwise, process the token using the rules for the "in head" insertion mode.
If the token does not have an attribute with the name "type", or if it does, but that attribute's value is not a case-insensitive match for the string "hidden", or, if the current table is tainted, then: act as described in the "anything else" entry below.
Otherwise:
Insert an HTML element for the token.
If the form element
pointer is not null, then associate
the input element with the form element
pointed to by the form
element pointer.
Pop that input element off the stack of
open elements.
If the current node is not the root html element, then this is a parse error..
It can only be the current node in the fragment case.
Parse error. Process the token using the rules for the "in body" insertion mode, with the following exception:
If the current node is a table, tbody,
tfoot, thead, or tr
element, then, whenever a node would be inserted into the current node, it must instead be inserted into the
foster parent element, and the current table must be marked as tainted. (Once the current
table has been tainted, whitespace characters
are inserted into the foster parent element
instead of the current node.)
The foster parent element is the parent element
of the last table element in the stack of open elements, if there is a table element and it has such a parent element.
If there is no table element in the stack of open elements (fragment
case), then the foster parent element
is the first element in the stack of open elements
(the html element). Otherwise, if there
is a table element in the stack of open elements, but the last table element in the stack of
open elements has no parent, or its parent node is not an element,
then the foster parent element is the
element before the last table element
in the stack of open elements.
If the foster parent element is the
parent element of the last table
element in the stack of open elements, then the new
node must be inserted immediately before the last table element in the stack of
open elements in the foster parent
element; otherwise, the new node must be appended to
the foster parent element.
When the steps above require the UA to clear the stack
back to a table context, it means that the UA must, while the current node is not a table element or an html element, pop elements from the stack of open elements.
The current node being an html element after this process is a fragment case.
When the insertion mode is "in caption", tokens must be handled as follows:
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Now, if the current node is not a caption element, then this is a parse error.
Pop elements from this stack until a caption element has been popped from the
stack.
Clear the list of active formatting elements up to the last marker.
Switch the insertion mode to "in table".
Parse error. 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.
The fake end tag token here can only be ignored in the fragment case.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
When the insertion mode is "in column group", tokens must be handled as follows:
Insert the character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
If the current node is the root html element, then this is a parse error, ignore the token. (fragment case)
Otherwise, pop the current node (which will be
a colgroup element) from the stack of open elements. Switch the insertion mode to "in table".
Parse error. Ignore the token.
If the current node is the root html element, then stop
parsing. (fragment case)
Otherwise, act as described in the "anything else" entry below.
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.
The fake end tag token here can only be ignored in the fragment case.
When the insertion mode is "in table body", tokens must be handled as follows:
Clear the stack back to a table body context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in row".
Parse error. Act as if a start tag with the tag name "tr" had been seen, then reprocess the current token.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token.
Otherwise:
Clear the stack back to a table body context. (See below.)
Pop the current node from the stack of open elements. Switch the insertion mode to "in table".
If the stack of open elements does not have a
tbody, thead, or tfoot element in
table scope, this is a parse error. Ignore the
token. (fragment case)
Otherwise:
Clear the stack back to a table body context. (See below.)
Act as if an end tag with the same tag name as the current node ("tbody", "tfoot", or "thead") had been seen, then reprocess the current token.
Parse error. Ignore the token.
Process the token using the rules for the "in table" insertion mode.
When the steps above require the UA to clear the stack
back to a table body context, it means that the UA must, while the
current node is not a tbody, tfoot,
thead, or html element, pop elements from the stack of open elements.
The current node being an html element after this process is a fragment case.
When the insertion mode is "in row", tokens must be handled as follows:
Clear the stack back to a table row context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in cell".
Insert a marker at the end of the list of active formatting elements.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Clear the stack back to a table row context. (See below.)
Pop the current node (which will be a tr element) from the stack of
open elements. Switch the insertion mode
to "in table
body".
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.
The fake end tag token here can only be ignored in the fragment case.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token.
Otherwise, act as if an end tag with the tag name "tr" had been seen, then reprocess the current token.
Parse error. Ignore the token.
Process the token using the rules for the "in table" insertion mode.
When the steps above require the UA to clear the stack
back to a table row context, it means that the UA must, while the current node is not a tr element or an html element, pop elements from the stack of open elements.
The current node being an html element after this process is a fragment case.
When the insertion mode is "in cell", tokens must be handled as follows:
If the stack of open elements does not have an element in table scope with the same tag name as that of the token, then this is a parse error and the token must be ignored.
Otherwise:
Now, if the current node is not an element with the same tag name as the token, then this is a parse error.
Pop elements from this stack until an element with the same tag name as the token has been popped from the stack.
Clear the list of active formatting elements up to the last marker.
Switch the insertion mode to "in row". (The current node will be a tr element at this point.)
If the stack of open elements does not
have a
td or th element in table scope, then this
is a parse error; ignore the token. (fragment case)
Otherwise, close the cell (see below) and reprocess the current token.
Parse error. Ignore the token.
If the stack of open elements does not have an element in table scope with the same tag name as that of the token (which can only happen for "tbody", "tfoot" and "thead", or, in the fragment case), then this is a parse error and the token must be ignored.
Otherwise, close the cell (see below) and reprocess the current token.
Process the token using the rules for the "in body" insertion mode.
Where the steps above say to close the cell, they mean to run the following algorithm:
If the stack of open elements has a td element in
table scope, then act as if an end tag token with the tag name "td"
had been seen.
Otherwise, the stack of open elements will have a
th element in table scope; act as if an end tag token
with the tag name "th" had been seen.
The stack of open elements cannot have
both a td and a th element in table scope at the same time, nor can it have
neither when the insertion mode is "in cell".
When the insertion mode is "in select", tokens must be handled as follows:
Insert the token's character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
If the current node is an option
element, act as if an end tag with the tag name "option" had been seen.
Insert an HTML element for the token.
If the current node is an option
element, act as if an end tag with the tag name "option" had been seen.
If the current node is an
optgroup element, act as if an end tag with the tag name
"optgroup" had been seen.
Insert an HTML element for the token.
First, if the current node is an
option element, and the node immediately before it in the
stack of open elements is an optgroup
element, then act as if an end tag with the tag name "option" had been
seen.
If the current node is an
optgroup element, then pop that node from the stack of open elements. Otherwise, this is a parse error, ignore the token.
If the current node is an option
element, then pop that node from the stack of open
elements. Otherwise, this is a parse error,
ignore the token.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Pop elements from the stack of open elements
until a select element has been popped from the stack.
Parse error. Act as if the token had been an end tag with the tag name "select" instead.
Parse error. Act as if an end tag with the tag name "select" had been seen, and reprocess the token.
If the current node is not the root html element, then this is a parse error..
It can only be the current node in the fragment case.
Parse error. Ignore the token.
When the insertion mode is "in select in table", tokens must be handled as follows:
Parse error. Act as if an end tag with the tag name "select" had been seen, and reprocess the token.
If the stack of open elements has an element in table scope 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.
Process the token using the rules for the "in select" insertion mode.
When the insertion mode is "after body", tokens must be handled as follows:
Process the token using the rules for the "in body" insertion mode.
Append a Comment node to the first element in the stack of open elements (the html element), with the data attribute set to the data given in the comment
token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
If the parser was originally created as part of the HTML fragment parsing algorithm, this is a parse error; ignore the token. (fragment case)
Otherwise, switch the insertion mode to "after after body".
Parse error. Switch the insertion mode to "in body" and reprocess the token.
When the insertion mode is "in frameset", tokens must be handled as follows:
Insert the character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token.
If the current node is the root html element, then this is a parse error; ignore the token. (fragment case)
Otherwise, pop the current node from the stack of open elements.
If the parser was not originally created as part of the HTML fragment parsing algorithm (fragment case), and the current
node is no longer a frameset element, then switch the
insertion mode to "after frameset".
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Process the token using the rules for the "in body" insertion mode.
If the current node is not the root html element, then this is a parse error..
It can only be the current node in the fragment case.
Parse error. Ignore the token.
When the insertion mode is "after frameset", tokens must be handled as follows:
Insert the character into the current node.
Append a Comment node to the current
node with the data attribute set to the data
given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Switch the insertion mode to "after after frameset".
Parse error. Ignore the token.
This doesn't handle UAs that don't support frames, or that do support frames but want to show the NOFRAMES content. Supporting the former is easy; supporting the latter is harder.
When the insertion mode is "after after body", tokens must be handled as follows:
Append a Comment node to the Document object
with the data attribute set to the data given in
the comment token.
Process the token using the rules for the "in body" insertion mode.
Parse error. Switch the insertion mode to "in body" and reprocess the token.
When the insertion mode is "after after frameset", tokens must be handled as follows:
Append a Comment node to the Document object
with the data attribute set to the data given in
the comment token.
Process the token using the rules for the "in body" insertion mode.
Parse error. Switch the insertion mode to "in frameset" and reprocess the token.
Once the user agent stops parsing the document, the user agent must follow the steps in this section.
First, the rules for when a script completes loading start applying (script execution is no longer managed by the parser).
If any of the scripts in the list of scripts that
will execute as soon as possible have completed
loading, or if the list of
scripts that will execute asynchronously is not empty and the first
script in that list has completed loading,
then the user agent must act as if those scripts just completed loading,
following the rules given for that in the script element definition.
Then, if the list of scripts that will execute when the document has finished parsing is not empty, and the first item in this list has already completed loading, then the user agent must act as if that script just finished loading.
By this point, there will be no scripts that have loaded but have not yet been executed.
The user agent must then fire a simple event
called DOMContentLoaded at the
Document.
Once everything that delays
the load event has completed, the user agent must fire a load
event at the body element.
delaying the load event for things like image loads allows for intranet port scans (even without javascript!). Should we really encode that into the spec?