mozilla-central/parser/html/javasrc/TreeBuilder.java

Source code

Revision control

Copy as Markdown

Other Tools

/*
* Copyright (c) 2007 Henri Sivonen
* Copyright (c) 2007-2017 Mozilla Foundation
* Portions of comments Copyright 2004-2008 Apple Computer, Inc., Mozilla
* Foundation, and Opera Software ASA.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/*
* The comments following this one that use the same comment syntax as this
* comment are quotes from the WHATWG HTML 5 spec as of 27 June 2007
* amended as of June 28 2007.
* That document came with this statement:
* "© Copyright 2004-2007 Apple Computer, Inc., Mozilla Foundation, and
* Opera Software ASA. You are granted a license to use, reproduce and
* create derivative works of this document."
*/
package nu.validator.htmlparser.impl;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.xml.sax.ErrorHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import nu.validator.htmlparser.annotation.Auto;
import nu.validator.htmlparser.annotation.Const;
import nu.validator.htmlparser.annotation.IdType;
import nu.validator.htmlparser.annotation.Inline;
import nu.validator.htmlparser.annotation.Literal;
import nu.validator.htmlparser.annotation.Local;
import nu.validator.htmlparser.annotation.NoLength;
import nu.validator.htmlparser.annotation.NsUri;
import nu.validator.htmlparser.common.DocumentMode;
import nu.validator.htmlparser.common.DocumentModeHandler;
import nu.validator.htmlparser.common.Interner;
import nu.validator.htmlparser.common.TokenHandler;
import nu.validator.htmlparser.common.XmlViolationPolicy;
public abstract class TreeBuilder<T> implements TokenHandler,
TreeBuilderState<T> {
/**
* Array version of U+FFFD.
*/
private static final @NoLength char[] REPLACEMENT_CHARACTER = { '\uFFFD' };
// Start dispatch groups
final static int OTHER = 0;
final static int A = 1;
final static int BASE = 2;
final static int BODY = 3;
final static int BR = 4;
final static int BUTTON = 5;
final static int CAPTION = 6;
final static int COL = 7;
final static int COLGROUP = 8;
final static int FORM = 9;
final static int FRAME = 10;
final static int FRAMESET = 11;
final static int IMAGE = 12;
final static int INPUT = 13;
final static int RT_OR_RP = 14;
final static int LI = 15;
final static int LINK_OR_BASEFONT_OR_BGSOUND = 16;
final static int MATH = 17;
final static int META = 18;
final static int SVG = 19;
final static int HEAD = 20;
final static int HR = 22;
final static int HTML = 23;
final static int NOBR = 24;
final static int NOFRAMES = 25;
final static int NOSCRIPT = 26;
final static int OPTGROUP = 27;
final static int OPTION = 28;
final static int P = 29;
final static int PLAINTEXT = 30;
final static int SCRIPT = 31;
final static int SELECT = 32;
final static int STYLE = 33;
final static int TABLE = 34;
final static int TEXTAREA = 35;
final static int TITLE = 36;
final static int TR = 37;
final static int XMP = 38;
final static int TBODY_OR_THEAD_OR_TFOOT = 39;
final static int TD_OR_TH = 40;
final static int DD_OR_DT = 41;
final static int H1_OR_H2_OR_H3_OR_H4_OR_H5_OR_H6 = 42;
final static int MARQUEE_OR_APPLET = 43;
final static int PRE_OR_LISTING = 44;
final static int B_OR_BIG_OR_CODE_OR_EM_OR_I_OR_S_OR_SMALL_OR_STRIKE_OR_STRONG_OR_TT_OR_U = 45;
final static int UL_OR_OL_OR_DL = 46;
final static int IFRAME = 47;
final static int EMBED = 48;
final static int AREA_OR_WBR = 49;
final static int DIV_OR_BLOCKQUOTE_OR_CENTER_OR_MENU = 50;
final static int ADDRESS_OR_ARTICLE_OR_ASIDE_OR_DETAILS_OR_DIALOG_OR_DIR_OR_FIGCAPTION_OR_FIGURE_OR_FOOTER_OR_HEADER_OR_HGROUP_OR_MAIN_OR_NAV_OR_SEARCH_OR_SECTION_OR_SUMMARY = 51;
final static int RUBY_OR_SPAN_OR_SUB_OR_SUP_OR_VAR = 52;
final static int RB_OR_RTC = 53;
final static int PARAM_OR_SOURCE_OR_TRACK = 55;
final static int MGLYPH_OR_MALIGNMARK = 56;
final static int MI_MO_MN_MS_MTEXT = 57;
final static int ANNOTATION_XML = 58;
final static int FOREIGNOBJECT_OR_DESC = 59;
final static int NOEMBED = 60;
final static int FIELDSET = 61;
final static int OUTPUT = 62;
final static int OBJECT = 63;
final static int FONT = 64;
final static int KEYGEN = 65;
final static int TEMPLATE = 66;
final static int IMG = 67;
// start insertion modes
private static final int IN_ROW = 0;
private static final int IN_TABLE_BODY = 1;
private static final int IN_TABLE = 2;
private static final int IN_CAPTION = 3;
private static final int IN_CELL = 4;
private static final int FRAMESET_OK = 5;
private static final int IN_BODY = 6;
private static final int IN_HEAD = 7;
private static final int IN_HEAD_NOSCRIPT = 8;
// no fall-through
private static final int IN_COLUMN_GROUP = 9;
// no fall-through
private static final int IN_SELECT_IN_TABLE = 10;
private static final int IN_SELECT = 11;
// no fall-through
private static final int AFTER_BODY = 12;
// no fall-through
private static final int IN_FRAMESET = 13;
private static final int AFTER_FRAMESET = 14;
// no fall-through
private static final int INITIAL = 15;
// could add fall-through
private static final int BEFORE_HTML = 16;
// could add fall-through
private static final int BEFORE_HEAD = 17;
// no fall-through
private static final int AFTER_HEAD = 18;
// no fall-through
private static final int AFTER_AFTER_BODY = 19;
// no fall-through
private static final int AFTER_AFTER_FRAMESET = 20;
// no fall-through
private static final int TEXT = 21;
private static final int IN_TEMPLATE = 22;
// start charset states
private static final int CHARSET_INITIAL = 0;
private static final int CHARSET_C = 1;
private static final int CHARSET_H = 2;
private static final int CHARSET_A = 3;
private static final int CHARSET_R = 4;
private static final int CHARSET_S = 5;
private static final int CHARSET_E = 6;
private static final int CHARSET_T = 7;
private static final int CHARSET_EQUALS = 8;
private static final int CHARSET_SINGLE_QUOTED = 9;
private static final int CHARSET_DOUBLE_QUOTED = 10;
private static final int CHARSET_UNQUOTED = 11;
// end pseudo enums
@Literal private final static String[] QUIRKY_PUBLIC_IDS = {
"+//silmaril//dtd html pro v0r11 19970101//",
"-//advasoft ltd//dtd html 3.0 aswedit + extensions//",
"-//as//dtd html 3.0 aswedit + extensions//",
"-//ietf//dtd html 2.0 level 1//",
"-//ietf//dtd html 2.0 level 2//",
"-//ietf//dtd html 2.0 strict level 1//",
"-//ietf//dtd html 2.0 strict level 2//",
"-//ietf//dtd html 2.0 strict//",
"-//ietf//dtd html 2.0//",
"-//ietf//dtd html 2.1e//",
"-//ietf//dtd html 3.0//",
"-//ietf//dtd html 3.2 final//",
"-//ietf//dtd html 3.2//",
"-//ietf//dtd html 3//",
"-//ietf//dtd html level 0//",
"-//ietf//dtd html level 1//",
"-//ietf//dtd html level 2//",
"-//ietf//dtd html level 3//",
"-//ietf//dtd html strict level 0//",
"-//ietf//dtd html strict level 1//",
"-//ietf//dtd html strict level 2//",
"-//ietf//dtd html strict level 3//",
"-//ietf//dtd html strict//",
"-//ietf//dtd html//",
"-//metrius//dtd metrius presentational//",
"-//microsoft//dtd internet explorer 2.0 html strict//",
"-//microsoft//dtd internet explorer 2.0 html//",
"-//microsoft//dtd internet explorer 2.0 tables//",
"-//microsoft//dtd internet explorer 3.0 html strict//",
"-//microsoft//dtd internet explorer 3.0 html//",
"-//microsoft//dtd internet explorer 3.0 tables//",
"-//netscape comm. corp.//dtd html//",
"-//netscape comm. corp.//dtd strict html//",
"-//o'reilly and associates//dtd html 2.0//",
"-//o'reilly and associates//dtd html extended 1.0//",
"-//o'reilly and associates//dtd html extended relaxed 1.0//",
"-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//",
"-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//",
"-//spyglass//dtd html 2.0 extended//",
"-//sq//dtd html 2.0 hotmetal + extensions//",
"-//sun microsystems corp.//dtd hotjava html//",
"-//sun microsystems corp.//dtd hotjava strict html//",
"-//w3c//dtd html 3 1995-03-24//", "-//w3c//dtd html 3.2 draft//",
"-//w3c//dtd html 3.2 final//", "-//w3c//dtd html 3.2//",
"-//w3c//dtd html 3.2s draft//", "-//w3c//dtd html 4.0 frameset//",
"-//w3c//dtd html 4.0 transitional//",
"-//w3c//dtd html experimental 19960712//",
"-//w3c//dtd html experimental 970421//", "-//w3c//dtd w3 html//",
"-//w3o//dtd w3 html 3.0//", "-//webtechs//dtd mozilla html 2.0//",
"-//webtechs//dtd mozilla html//" };
private static final int NOT_FOUND_ON_STACK = Integer.MAX_VALUE;
// [NOCPP[
private static final @Local String HTML_LOCAL = "html";
// ]NOCPP]
private int mode = INITIAL;
private int originalMode = INITIAL;
/**
* Used only when moving back to IN_BODY.
*/
private boolean framesetOk = true;
protected Tokenizer tokenizer;
// [NOCPP[
protected ErrorHandler errorHandler;
private DocumentModeHandler documentModeHandler;
// ]NOCPP]
private boolean scriptingEnabled = false;
private boolean needToDropLF;
// [NOCPP[
private boolean wantingComments;
// ]NOCPP]
private boolean fragment;
private @Local String contextName;
private @NsUri String contextNamespace;
private T contextNode;
/**
* Stack of template insertion modes
*/
private @Auto int[] templateModeStack;
/**
* Current template mode stack pointer.
*/
private int templateModePtr = -1;
private @Auto StackNode<T>[] stackNodes;
/**
* Index of the earliest possible unused or empty element in stackNodes.
*/
private int stackNodesIdx = -1;
private int numStackNodes = 0;
private @Auto StackNode<T>[] stack;
private int currentPtr = -1;
private @Auto StackNode<T>[] listOfActiveFormattingElements;
private int listPtr = -1;
private T formPointer;
private T headPointer;
protected @Auto char[] charBuffer;
protected int charBufferLen = 0;
private boolean quirks = false;
private boolean forceNoQuirks = false;
private boolean allowDeclarativeShadowRoots = false;
private boolean keepBuffer = false;
// [NOCPP[
private boolean reportingDoctype = true;
private XmlViolationPolicy namePolicy = XmlViolationPolicy.ALTER_INFOSET;
private final Map<String, LocatorImpl> idLocations = new HashMap<String, LocatorImpl>();
// ]NOCPP]
protected TreeBuilder() {
fragment = false;
}
/**
* Reports an condition that would make the infoset incompatible with XML
* 1.0 as fatal.
*
* @throws SAXException
* @throws SAXParseException
*/
protected void fatal() throws SAXException {
}
// CPPONLY: @Inline private @Creator Object htmlCreator(@HtmlCreator Object htmlCreator) {
// CPPONLY: @Creator Object creator;
// CPPONLY: creator.html = htmlCreator;
// CPPONLY: return creator;
// CPPONLY: }
// CPPONLY:
// CPPONLY: @Inline private @Creator Object svgCreator(@SvgCreator Object svgCreator) {
// CPPONLY: @Creator Object creator;
// CPPONLY: creator.svg = svgCreator;
// CPPONLY: return creator;
// CPPONLY: }
// [NOCPP[
protected final void fatal(Exception e) throws SAXException {
SAXParseException spe = new SAXParseException(e.getMessage(),
tokenizer, e);
if (errorHandler != null) {
errorHandler.fatalError(spe);
}
throw spe;
}
final void fatal(String s) throws SAXException {
SAXParseException spe = new SAXParseException(s, tokenizer);
if (errorHandler != null) {
errorHandler.fatalError(spe);
}
throw spe;
}
/**
* Reports a Parse Error.
*
* @param message
* the message
* @throws SAXException
*/
final void err(String message) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck(message);
}
/**
* Reports a Parse Error without checking if an error handler is present.
*
* @param message
* the message
* @throws SAXException
*/
final void errNoCheck(String message) throws SAXException {
SAXParseException spe = new SAXParseException(message, tokenizer);
errorHandler.error(spe);
}
private void errListUnclosedStartTags(int eltPos) throws SAXException {
if (currentPtr != -1) {
for (int i = currentPtr; i > eltPos; i--) {
reportUnclosedElementNameAndLocation(i);
}
}
}
/**
* Reports the name and location of an unclosed element.
*
* @throws SAXException
*/
private final void reportUnclosedElementNameAndLocation(int pos) throws SAXException {
StackNode<T> node = stack[pos];
if (node.isOptionalEndTag()) {
return;
}
TaintableLocatorImpl locator = node.getLocator();
if (locator.isTainted()) {
return;
}
locator.markTainted();
SAXParseException spe = new SAXParseException(
"Unclosed element \u201C" + node.popName + "\u201D.", locator);
errorHandler.error(spe);
}
/**
* Reports a warning
*
* @param message
* the message
* @throws SAXException
*/
final void warn(String message) throws SAXException {
if (errorHandler == null) {
return;
}
SAXParseException spe = new SAXParseException(message, tokenizer);
errorHandler.warning(spe);
}
/**
* Reports a warning with an explicit locator
*
* @param message
* the message
* @throws SAXException
*/
final void warn(String message, Locator locator) throws SAXException {
if (errorHandler == null) {
return;
}
SAXParseException spe = new SAXParseException(message, locator);
errorHandler.warning(spe);
}
// ]NOCPP]
public void setKeepBuffer(boolean keepBuffer) {
this.keepBuffer = keepBuffer;
}
public boolean dropBufferIfLongerThan(int length) {
if (charBuffer.length > length) {
charBuffer = null;
return true;
}
return false;
}
@SuppressWarnings("unchecked") public final void startTokenization(Tokenizer self) throws SAXException {
tokenizer = self;
stackNodes = new StackNode[64];
stack = new StackNode[64];
templateModeStack = new int[64];
listOfActiveFormattingElements = new StackNode[64];
needToDropLF = false;
originalMode = INITIAL;
templateModePtr = -1;
stackNodesIdx = 0;
numStackNodes = 0;
currentPtr = -1;
listPtr = -1;
formPointer = null;
headPointer = null;
// [NOCPP[
idLocations.clear();
wantingComments = wantsComments();
// ]NOCPP]
start(fragment);
charBufferLen = 0;
if (!keepBuffer) {
charBuffer = null;
}
framesetOk = true;
if (fragment) {
T elt;
if (contextNode != null) {
elt = contextNode;
} else {
elt = createHtmlElementSetAsRoot(tokenizer.emptyAttributes());
}
// When the context node is not in the HTML namespace, contrary
// to the spec, the first node on the stack is not set to "html"
// in the HTML namespace. Instead, it is set to a node that has
// the characteristics of the appropriate "adjusted current node".
// This way, there is no need to perform "adjusted current node"
// checks during tree construction. Instead, it's sufficient to
// just look at the current node. However, this also means that it
// is not safe to treat "html" in the HTML namespace as a sentinel
// that ends stack popping. Instead, stack popping loops that are
// meant not to pop the first element on the stack need to check
// for currentPos becoming zero.
if (contextNamespace == "http://www.w3.org/2000/svg") {
ElementName elementName = ElementName.SVG;
if ("title" == contextName || "desc" == contextName
|| "foreignObject" == contextName) {
// These elements are all alike and we don't care about
// the exact name.
elementName = ElementName.FOREIGNOBJECT;
}
// This is the SVG variant of the StackNode constructor.
StackNode<T> node = createStackNode(elementName,
elementName.getCamelCaseName(), elt
// [NOCPP[
, errorHandler == null ? null
: new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
currentPtr++;
stack[currentPtr] = node;
tokenizer.setState(Tokenizer.DATA);
// The frameset-ok flag is set even though <frameset> never
// ends up being allowed as HTML frameset in the fragment case.
mode = FRAMESET_OK;
} else if (contextNamespace == "http://www.w3.org/1998/Math/MathML") {
ElementName elementName = ElementName.MATH;
if ("mi" == contextName || "mo" == contextName
|| "mn" == contextName || "ms" == contextName
|| "mtext" == contextName) {
// These elements are all alike and we don't care about
// the exact name.
elementName = ElementName.MTEXT;
} else if ("annotation-xml" == contextName) {
elementName = ElementName.ANNOTATION_XML;
// Blink does not check the encoding attribute of the
// annotation-xml element innerHTML is being set on.
// Let's do the same at least until
// is resolved.
}
// This is the MathML variant of the StackNode constructor.
StackNode<T> node = createStackNode(elementName, elt,
elementName.getName(), false
// [NOCPP[
, errorHandler == null ? null
: new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
currentPtr++;
stack[currentPtr] = node;
tokenizer.setState(Tokenizer.DATA);
// The frameset-ok flag is set even though <frameset> never
// ends up being allowed as HTML frameset in the fragment case.
mode = FRAMESET_OK;
} else { // html
StackNode<T> node = createStackNode(ElementName.HTML, elt
// [NOCPP[
, errorHandler == null ? null
: new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
currentPtr++;
stack[currentPtr] = node;
if ("template" == contextName) {
pushTemplateMode(IN_TEMPLATE);
}
resetTheInsertionMode();
formPointer = getFormPointerForContext(contextNode);
if ("title" == contextName || "textarea" == contextName) {
tokenizer.setState(Tokenizer.RCDATA);
} else if ("style" == contextName || "xmp" == contextName
|| "iframe" == contextName || "noembed" == contextName
|| "noframes" == contextName
|| (scriptingEnabled && "noscript" == contextName)) {
tokenizer.setState(Tokenizer.RAWTEXT);
} else if ("plaintext" == contextName) {
tokenizer.setState(Tokenizer.PLAINTEXT);
} else if ("script" == contextName) {
tokenizer.setState(Tokenizer.SCRIPT_DATA);
} else {
tokenizer.setState(Tokenizer.DATA);
}
}
} else {
mode = INITIAL;
// If we are viewing XML source, put a foreign element permanently
// on the stack so that cdataSectionAllowed() returns true.
// CPPONLY: if (tokenizer.isViewingXmlSource()) {
// CPPONLY: T elt = createElement("http://www.w3.org/2000/svg",
// CPPONLY: "svg",
// CPPONLY: tokenizer.emptyAttributes(), null,
// CPPONLY: svgCreator(NS_NewSVGSVGElement));
// CPPONLY: StackNode<T> node = createStackNode(ElementName.SVG,
// CPPONLY: "svg",
// CPPONLY: elt);
// CPPONLY: currentPtr++;
// CPPONLY: stack[currentPtr] = node;
// CPPONLY: }
}
}
public final void doctype(@Local String name, String publicIdentifier,
String systemIdentifier, boolean forceQuirks) throws SAXException {
needToDropLF = false;
if (!isInForeign() && mode == INITIAL) {
// [NOCPP[
if (reportingDoctype) {
// ]NOCPP]
String emptyString = Portability.newEmptyString();
appendDoctypeToDocument(name == null ? "" : name,
publicIdentifier == null ? emptyString
: publicIdentifier,
systemIdentifier == null ? emptyString
: systemIdentifier);
Portability.releaseString(emptyString);
// [NOCPP[
}
// ]NOCPP]
if (isQuirky(name, publicIdentifier, systemIdentifier,
forceQuirks)) {
errQuirkyDoctype();
documentModeInternal(DocumentMode.QUIRKS_MODE,
publicIdentifier, systemIdentifier);
} else if (isAlmostStandards(publicIdentifier,
systemIdentifier)) {
errAlmostStandardsDoctype();
documentModeInternal(
DocumentMode.ALMOST_STANDARDS_MODE,
publicIdentifier, systemIdentifier);
} else {
// [NOCPP[
if ((Portability.literalEqualsString(
"-//W3C//DTD HTML 4.0//EN", publicIdentifier) && (systemIdentifier == null || Portability.literalEqualsString(
systemIdentifier)))
|| (Portability.literalEqualsString(
"-//W3C//DTD HTML 4.01//EN",
publicIdentifier) && (systemIdentifier == null || Portability.literalEqualsString(
systemIdentifier)))
|| (Portability.literalEqualsString(
"-//W3C//DTD XHTML 1.0 Strict//EN",
publicIdentifier) && Portability.literalEqualsString(
systemIdentifier))
|| (Portability.literalEqualsString(
"-//W3C//DTD XHTML 1.1//EN",
publicIdentifier) && Portability.literalEqualsString(
systemIdentifier))
) {
err("Obsolete doctype. Expected \u201C<!DOCTYPE html>\u201D.");
} else if (!((systemIdentifier == null || Portability.literalEqualsString(
"about:legacy-compat", systemIdentifier)) && publicIdentifier == null)) {
err("Legacy doctype. Expected \u201C<!DOCTYPE html>\u201D.");
}
// ]NOCPP]
documentModeInternal(DocumentMode.STANDARDS_MODE,
publicIdentifier, systemIdentifier);
}
/*
*
* Then, switch to the root element mode of the tree construction
* stage.
*/
mode = BEFORE_HTML;
return;
}
/*
* A DOCTYPE token Parse error.
*/
errStrayDoctype();
/*
* Ignore the token.
*/
return;
}
public final void comment(@NoLength char[] buf, int start, int length)
throws SAXException {
needToDropLF = false;
// [NOCPP[
if (!wantingComments) {
return;
}
// ]NOCPP]
if (!isInForeign()) {
switch (mode) {
case INITIAL:
case BEFORE_HTML:
case AFTER_AFTER_BODY:
case AFTER_AFTER_FRAMESET:
/*
* A comment token Append a Comment node to the Document
* object with the data attribute set to the data given in
* the comment token.
*/
appendCommentToDocument(buf, start, length);
return;
case AFTER_BODY:
/*
* A comment token 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.
*/
flushCharacters();
appendComment(stack[0].node, buf, start, length);
return;
default:
break;
}
}
/*
* A comment token Append a Comment node to the current node with the
* data attribute set to the data given in the comment token.
*/
flushCharacters();
appendComment(stack[currentPtr].node, buf, start, length);
return;
}
/**
* @see nu.validator.htmlparser.common.TokenHandler#characters(char[], int,
* int)
*/
public final void characters(@Const @NoLength char[] buf, int start, int length)
throws SAXException {
// Note: Can't attach error messages to EOF in C++ yet
// CPPONLY: if (tokenizer.isViewingXmlSource()) {
// CPPONLY: return;
// CPPONLY: }
if (needToDropLF) {
needToDropLF = false;
if (buf[start] == '\n') {
start++;
length--;
if (length == 0) {
return;
}
}
}
// optimize the most common case
switch (mode) {
case IN_BODY:
case IN_CELL:
case IN_CAPTION:
if (!isInForeignButNotHtmlOrMathTextIntegrationPoint()) {
reconstructTheActiveFormattingElements();
}
// CPPONLY: MOZ_FALLTHROUGH;
case TEXT:
accumulateCharacters(buf, start, length);
return;
case IN_TABLE:
case IN_TABLE_BODY:
case IN_ROW:
accumulateCharactersForced(buf, start, length);
return;
default:
int end = start + length;
charactersloop: for (int i = start; i < end; i++) {
switch (buf[i]) {
case ' ':
case '\t':
case '\n':
case '\r':
case '\u000C':
/*
* A character token that is one of one of U+0009
* CHARACTER TABULATION, U+000A LINE FEED (LF),
* U+000C FORM FEED (FF), or U+0020 SPACE
*/
switch (mode) {
case INITIAL:
case BEFORE_HTML:
case BEFORE_HEAD:
/*
* Ignore the token.
*/
start = i + 1;
continue;
case IN_HEAD:
case IN_HEAD_NOSCRIPT:
case AFTER_HEAD:
case IN_COLUMN_GROUP:
case IN_FRAMESET:
case AFTER_FRAMESET:
/*
* Append the character to the current node.
*/
continue;
case FRAMESET_OK:
case IN_TEMPLATE:
case IN_BODY:
case IN_CELL:
case IN_CAPTION:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* Reconstruct the active formatting
* elements, if any.
*/
if (!isInForeignButNotHtmlOrMathTextIntegrationPoint()) {
flushCharacters();
reconstructTheActiveFormattingElements();
}
/*
* Append the token's character to the
* current node.
*/
break charactersloop;
case IN_SELECT:
case IN_SELECT_IN_TABLE:
break charactersloop;
case IN_TABLE:
case IN_TABLE_BODY:
case IN_ROW:
accumulateCharactersForced(buf, i, 1);
start = i + 1;
continue;
case AFTER_BODY:
case AFTER_AFTER_BODY:
case AFTER_AFTER_FRAMESET:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* Reconstruct the active formatting
* elements, if any.
*/
flushCharacters();
reconstructTheActiveFormattingElements();
/*
* Append the token's character to the
* current node.
*/
continue;
}
// CPPONLY: MOZ_FALLTHROUGH_ASSERT();
default:
/*
* A character token that is not one of one of
* U+0009 CHARACTER TABULATION, U+000A LINE FEED
* (LF), U+000C FORM FEED (FF), or U+0020 SPACE
*/
switch (mode) {
case INITIAL:
/*
* Parse error.
*/
// [NOCPP[
// XXX figure out a way to report this in the Gecko View Source case
err("Non-space characters found without seeing a doctype first. Expected \u201C<!DOCTYPE html>\u201D.");
// ]NOCPP]
/*
*
* Set the document to quirks mode.
*/
documentModeInternal(
DocumentMode.QUIRKS_MODE, null,
null);
/*
* Then, switch to the root element mode of
* the tree construction stage
*/
mode = BEFORE_HTML;
/*
* and reprocess the current token.
*/
i--;
continue;
case BEFORE_HTML:
/*
* Create an HTMLElement node with the tag
* name html, in the HTML namespace. Append
* it to the Document object.
*/
// No need to flush characters here,
// because there's nothing to flush.
appendHtmlElementToDocumentAndPush();
/* Switch to the main mode */
mode = BEFORE_HEAD;
/*
* reprocess the current token.
*/
i--;
continue;
case BEFORE_HEAD:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* /Act as if a start tag token with the tag
* name "head" and no attributes had been
* seen,
*/
flushCharacters();
appendToCurrentNodeAndPushHeadElement(HtmlAttributes.EMPTY_ATTRIBUTES);
mode = IN_HEAD;
/*
* 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.
*/
i--;
continue;
case IN_HEAD:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* Act as if an end tag token with the tag
* name "head" had been seen,
*/
flushCharacters();
pop();
mode = AFTER_HEAD;
/*
* and reprocess the current token.
*/
i--;
continue;
case IN_HEAD_NOSCRIPT:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* Parse error. Act as if an end tag with
* the tag name "noscript" had been seen
*/
errNonSpaceInNoscriptInHead();
flushCharacters();
pop();
mode = IN_HEAD;
/*
* and reprocess the current token.
*/
i--;
continue;
case AFTER_HEAD:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* Act as if a start tag token with the tag
* name "body" and no attributes had been
* seen,
*/
flushCharacters();
appendToCurrentNodeAndPushBodyElement();
mode = FRAMESET_OK;
/*
* and then reprocess the current token.
*/
i--;
continue;
case FRAMESET_OK:
framesetOk = false;
mode = IN_BODY;
i--;
continue;
case IN_TEMPLATE:
case IN_BODY:
case IN_CELL:
case IN_CAPTION:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* Reconstruct the active formatting
* elements, if any.
*/
if (!isInForeignButNotHtmlOrMathTextIntegrationPoint()) {
flushCharacters();
reconstructTheActiveFormattingElements();
}
/*
* Append the token's character to the
* current node.
*/
break charactersloop;
case IN_TABLE:
case IN_TABLE_BODY:
case IN_ROW:
accumulateCharactersForced(buf, i, 1);
start = i + 1;
continue;
case IN_COLUMN_GROUP:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
start = i;
}
/*
* 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.
*/
if (currentPtr == 0 || stack[currentPtr].getGroup() ==
TreeBuilder.TEMPLATE) {
errNonSpaceInColgroupInFragment();
start = i + 1;
continue;
}
flushCharacters();
pop();
mode = IN_TABLE;
i--;
continue;
case IN_SELECT:
case IN_SELECT_IN_TABLE:
break charactersloop;
case AFTER_BODY:
errNonSpaceAfterBody();
fatal();
mode = framesetOk ? FRAMESET_OK : IN_BODY;
i--;
continue;
case IN_FRAMESET:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
// start index is adjusted below.
}
/*
* Parse error.
*/
errNonSpaceInFrameset();
/*
* Ignore the token.
*/
start = i + 1;
continue;
case AFTER_FRAMESET:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
// start index is adjusted below.
}
/*
* Parse error.
*/
errNonSpaceAfterFrameset();
/*
* Ignore the token.
*/
start = i + 1;
continue;
case AFTER_AFTER_BODY:
/*
* Parse error.
*/
errNonSpaceInTrailer();
/*
* Switch back to the main mode and
* reprocess the token.
*/
mode = framesetOk ? FRAMESET_OK : IN_BODY;
i--;
continue;
case AFTER_AFTER_FRAMESET:
if (start < i) {
accumulateCharacters(buf, start, i
- start);
// start index is adjusted below.
}
/*
* Parse error.
*/
errNonSpaceInTrailer();
/*
* Ignore the token.
*/
start = i + 1;
continue;
}
}
}
if (start < end) {
accumulateCharacters(buf, start, end - start);
}
}
}
/**
* @see nu.validator.htmlparser.common.TokenHandler#zeroOriginatingReplacementCharacter()
*/
public void zeroOriginatingReplacementCharacter() throws SAXException {
if (mode == TEXT) {
accumulateCharacters(REPLACEMENT_CHARACTER, 0, 1);
return;
}
if (currentPtr >= 0) {
if (isSpecialParentInForeign(stack[currentPtr])) {
return;
}
accumulateCharacters(REPLACEMENT_CHARACTER, 0, 1);
}
}
/**
* @see nu.validator.htmlparser.common.TokenHandler#zeroOrReplacementCharacter()
*/
public void zeroOrReplacementCharacter() throws SAXException {
zeroOriginatingReplacementCharacter();
}
public final void eof() throws SAXException {
flushCharacters();
// Note: Can't attach error messages to EOF in C++ yet
eofloop: for (;;) {
switch (mode) {
case INITIAL:
/*
* Parse error.
*/
// [NOCPP[
err("End of file seen without seeing a doctype first. Expected \u201C<!DOCTYPE html>\u201D.");
// ]NOCPP]
/*
*
* Set the document to quirks mode.
*/
documentModeInternal(DocumentMode.QUIRKS_MODE, null, null);
/*
* Then, switch to the root element mode of the tree
* construction stage
*/
mode = BEFORE_HTML;
/*
* and reprocess the current token.
*/
continue;
case BEFORE_HTML:
/*
* Create an HTMLElement node with the tag name html, in the
* HTML namespace. Append it to the Document object.
*/
appendHtmlElementToDocumentAndPush();
// XXX application cache manifest
/* Switch to the main mode */
mode = BEFORE_HEAD;
/*
* reprocess the current token.
*/
continue;
case BEFORE_HEAD:
appendToCurrentNodeAndPushHeadElement(HtmlAttributes.EMPTY_ATTRIBUTES);
mode = IN_HEAD;
continue;
case IN_HEAD:
// [NOCPP[
if (errorHandler != null && currentPtr > 1) {
errEofWithUnclosedElements();
}
// ]NOCPP]
while (currentPtr > 0) {
popOnEof();
}
mode = AFTER_HEAD;
continue;
case IN_HEAD_NOSCRIPT:
// [NOCPP[
errEofWithUnclosedElements();
// ]NOCPP]
while (currentPtr > 1) {
popOnEof();
}
mode = IN_HEAD;
continue;
case AFTER_HEAD:
appendToCurrentNodeAndPushBodyElement();
mode = IN_BODY;
continue;
case IN_TABLE_BODY:
case IN_ROW:
case IN_TABLE:
case IN_SELECT_IN_TABLE:
case IN_SELECT:
case IN_COLUMN_GROUP:
case FRAMESET_OK:
case IN_CAPTION:
case IN_CELL:
case IN_BODY:
// [NOCPP[
// i > 0 to stop in time in the foreign fragment case.
openelementloop: for (int i = currentPtr; i > 0; i--) {
int group = stack[i].getGroup();
switch (group) {
case DD_OR_DT:
case LI:
case P:
case TBODY_OR_THEAD_OR_TFOOT:
case TD_OR_TH:
case BODY:
case HTML:
break;
default:
errEofWithUnclosedElements();
break openelementloop;
}
}
// ]NOCPP]
if (isTemplateModeStackEmpty()) {
break eofloop;
}
// fall through to IN_TEMPLATE
// CPPONLY: MOZ_FALLTHROUGH;
case IN_TEMPLATE:
int eltPos = findLast("template");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment;
break eofloop;
}
if (errorHandler != null) {
errListUnclosedStartTags(0);
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
popTemplateMode();
resetTheInsertionMode();
// Reprocess token.
continue;
case TEXT:
// [NOCPP[
if (errorHandler != null) {
errNoCheck("End of file seen when expecting text or an end tag.");
errListUnclosedStartTags(0);
}
// ]NOCPP]
// XXX mark script as already executed
if (originalMode == AFTER_HEAD) {
popOnEof();
}
popOnEof();
mode = originalMode;
continue;
case IN_FRAMESET:
// [NOCPP[
if (errorHandler != null && currentPtr > 0) {
errEofWithUnclosedElements();
}
// ]NOCPP]
break eofloop;
case AFTER_BODY:
case AFTER_FRAMESET:
case AFTER_AFTER_BODY:
case AFTER_AFTER_FRAMESET:
default:
// [NOCPP[
if (currentPtr == 0) { // This silliness is here to poison
// buggy compiler optimizations in
// GWT
System.currentTimeMillis();
}
// ]NOCPP]
break eofloop;
}
}
while (currentPtr > 0) {
popOnEof();
}
if (!fragment) {
popOnEof();
}
/* Stop parsing. */
}
/**
* @see nu.validator.htmlparser.common.TokenHandler#endTokenization()
*/
public final void endTokenization() throws SAXException {
formPointer = null;
headPointer = null;
contextName = null;
contextNode = null;
templateModeStack = null;
if (stack != null) {
while (currentPtr > -1) {
stack[currentPtr].release(this);
currentPtr--;
}
stack = null;
}
if (listOfActiveFormattingElements != null) {
while (listPtr > -1) {
if (listOfActiveFormattingElements[listPtr] != null) {
listOfActiveFormattingElements[listPtr].release(this);
}
listPtr--;
}
listOfActiveFormattingElements = null;
}
if (stackNodes != null) {
for (int i = 0; i < numStackNodes; i++) {
assert stackNodes[i].isUnused();
Portability.delete(stackNodes[i]);
}
numStackNodes = 0;
stackNodesIdx = 0;
stackNodes = null;
}
// [NOCPP[
idLocations.clear();
// ]NOCPP]
if (!keepBuffer) {
charBuffer = null;
}
end();
}
public final void startTag(ElementName elementName,
HtmlAttributes attributes, boolean selfClosing) throws SAXException {
flushCharacters();
// [NOCPP[
boolean wasSelfClosing = selfClosing;
boolean voidElement = false;
if (errorHandler != null) {
// ID uniqueness
@IdType String id = attributes.getId();
if (id != null && !isTemplateContents()) {
LocatorImpl oldLoc = idLocations.get(id);
if (oldLoc != null) {
err("Duplicate ID \u201C" + id + "\u201D.");
errorHandler.warning(new SAXParseException(
"The first occurrence of ID \u201C" + id
+ "\u201D was here.", oldLoc));
} else {
idLocations.put(id, new LocatorImpl(tokenizer));
}
}
}
// ]NOCPP]
int eltPos;
needToDropLF = false;
starttagloop: for (;;) {
int group = elementName.getGroup();
@Local String name = elementName.getName();
if (isInForeign()) {
StackNode<T> currentNode = stack[currentPtr];
@NsUri String currNs = currentNode.ns;
if (!(currentNode.isHtmlIntegrationPoint() || (currNs == "http://www.w3.org/1998/Math/MathML" && ((currentNode.getGroup() == MI_MO_MN_MS_MTEXT && group != MGLYPH_OR_MALIGNMARK) || (currentNode.getGroup() == ANNOTATION_XML && group == SVG))))) {
switch (group) {
case B_OR_BIG_OR_CODE_OR_EM_OR_I_OR_S_OR_SMALL_OR_STRIKE_OR_STRONG_OR_TT_OR_U:
case DIV_OR_BLOCKQUOTE_OR_CENTER_OR_MENU:
case BODY:
case BR:
case RUBY_OR_SPAN_OR_SUB_OR_SUP_OR_VAR:
case DD_OR_DT:
case UL_OR_OL_OR_DL:
case EMBED:
case IMG:
case H1_OR_H2_OR_H3_OR_H4_OR_H5_OR_H6:
case HEAD:
case HR:
case LI:
case META:
case NOBR:
case P:
case PRE_OR_LISTING:
case TABLE:
case FONT:
// re-check FONT to deal with the special case
if (!(group == FONT && !(attributes.contains(AttributeName.COLOR)
|| attributes.contains(AttributeName.FACE) || attributes.contains(AttributeName.SIZE)))) {
errHtmlStartTagInForeignContext(name);
if (!fragment) {
while (!isSpecialParentInForeign(stack[currentPtr])) {
popForeign(-1, -1);
}
continue starttagloop;
} // else fall thru
}
// CPPONLY: MOZ_FALLTHROUGH;
default:
if ("http://www.w3.org/2000/svg" == currNs) {
attributes.adjustForSvg();
if (selfClosing) {
appendVoidElementToCurrentMayFosterSVG(
elementName, attributes);
selfClosing = false;
} else {
appendToCurrentNodeAndPushElementMayFosterSVG(
elementName, attributes);
}
attributes = null; // CPP
break starttagloop;
} else {
attributes.adjustForMath();
if (selfClosing) {
appendVoidElementToCurrentMayFosterMathML(
elementName, attributes);
selfClosing = false;
} else {
appendToCurrentNodeAndPushElementMayFosterMathML(
elementName, attributes);
}
attributes = null; // CPP
break starttagloop;
}
} // switch
} // foreignObject / annotation-xml
}
switch (mode) {
case IN_TEMPLATE:
switch (group) {
case COL:
popTemplateMode();
pushTemplateMode(IN_COLUMN_GROUP);
mode = IN_COLUMN_GROUP;
// Reprocess token.
continue;
case CAPTION:
case COLGROUP:
case TBODY_OR_THEAD_OR_TFOOT:
popTemplateMode();
pushTemplateMode(IN_TABLE);
mode = IN_TABLE;
// Reprocess token.
continue;
case TR:
popTemplateMode();
pushTemplateMode(IN_TABLE_BODY);
mode = IN_TABLE_BODY;
// Reprocess token.
continue;
case TD_OR_TH:
popTemplateMode();
pushTemplateMode(IN_ROW);
mode = IN_ROW;
// Reprocess token.
continue;
case META:
checkMetaCharset(attributes);
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case TITLE:
startTagTitleInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case BASE:
case LINK_OR_BASEFONT_OR_BGSOUND:
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case SCRIPT:
startTagScriptInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case NOFRAMES:
case STYLE:
startTagGenericRawText(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case TEMPLATE:
startTagTemplateInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
default:
popTemplateMode();
pushTemplateMode(IN_BODY);
mode = IN_BODY;
// Reprocess token.
continue;
}
case IN_ROW:
switch (group) {
case TD_OR_TH:
clearStackBackTo(findLastOrRoot(TreeBuilder.TR));
appendToCurrentNodeAndPushElement(
elementName,
attributes);
mode = IN_CELL;
insertMarker();
attributes = null; // CPP
break starttagloop;
case CAPTION:
case COL:
case COLGROUP:
case TBODY_OR_THEAD_OR_TFOOT:
case TR:
eltPos = findLastOrRoot(TreeBuilder.TR);
if (eltPos == 0) {
assert fragment || isTemplateContents();
errNoTableRowToClose();
break starttagloop;
}
clearStackBackTo(eltPos);
pop();
mode = IN_TABLE_BODY;
continue;
default:
// fall through to IN_TABLE
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_TABLE_BODY:
switch (group) {
case TR:
clearStackBackTo(findLastInTableScopeOrRootTemplateTbodyTheadTfoot());
appendToCurrentNodeAndPushElement(
elementName,
attributes);
mode = IN_ROW;
attributes = null; // CPP
break starttagloop;
case TD_OR_TH:
errStartTagInTableBody(name);
clearStackBackTo(findLastInTableScopeOrRootTemplateTbodyTheadTfoot());
appendToCurrentNodeAndPushElement(
ElementName.TR,
HtmlAttributes.EMPTY_ATTRIBUTES);
mode = IN_ROW;
continue;
case CAPTION:
case COL:
case COLGROUP:
case TBODY_OR_THEAD_OR_TFOOT:
eltPos = findLastInTableScopeOrRootTemplateTbodyTheadTfoot();
if (eltPos == 0 || stack[eltPos].getGroup() == TEMPLATE) {
assert fragment || isTemplateContents();
errStrayStartTag(name);
break starttagloop;
} else {
clearStackBackTo(eltPos);
pop();
mode = IN_TABLE;
continue;
}
default:
// fall through to IN_TABLE
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_TABLE:
intableloop: for (;;) {
switch (group) {
case CAPTION:
clearStackBackTo(findLastOrRoot(TreeBuilder.TABLE));
insertMarker();
appendToCurrentNodeAndPushElement(
elementName,
attributes);
mode = IN_CAPTION;
attributes = null; // CPP
break starttagloop;
case COLGROUP:
clearStackBackTo(findLastOrRoot(TreeBuilder.TABLE));
appendToCurrentNodeAndPushElement(
elementName,
attributes);
mode = IN_COLUMN_GROUP;
attributes = null; // CPP
break starttagloop;
case COL:
clearStackBackTo(findLastOrRoot(TreeBuilder.TABLE));
appendToCurrentNodeAndPushElement(
ElementName.COLGROUP,
HtmlAttributes.EMPTY_ATTRIBUTES);
mode = IN_COLUMN_GROUP;
continue starttagloop;
case TBODY_OR_THEAD_OR_TFOOT:
clearStackBackTo(findLastOrRoot(TreeBuilder.TABLE));
appendToCurrentNodeAndPushElement(
elementName,
attributes);
mode = IN_TABLE_BODY;
attributes = null; // CPP
break starttagloop;
case TR:
case TD_OR_TH:
clearStackBackTo(findLastOrRoot(TreeBuilder.TABLE));
appendToCurrentNodeAndPushElement(
ElementName.TBODY,
HtmlAttributes.EMPTY_ATTRIBUTES);
mode = IN_TABLE_BODY;
continue starttagloop;
case TEMPLATE:
// fall through to IN_HEAD
break intableloop;
case TABLE:
errTableSeenWhileTableOpen();
eltPos = findLastInTableScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment || isTemplateContents();
break starttagloop;
}
generateImpliedEndTags();
if (errorHandler != null && !isCurrent("table")) {
errNoCheckUnclosedElementsOnStack();
}
while (currentPtr >= eltPos) {
pop();
}
resetTheInsertionMode();
continue starttagloop;
case SCRIPT:
// XXX need to manage much more stuff
// here if
// supporting
// document.write()
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.SCRIPT_DATA, elementName);
attributes = null; // CPP
break starttagloop;
case STYLE:
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RAWTEXT, elementName);
attributes = null; // CPP
break starttagloop;
case INPUT:
errStartTagInTable(name);
if (!Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"hidden",
attributes.getValue(AttributeName.TYPE))) {
break intableloop;
}
appendVoidInputToCurrent(
attributes,
formPointer);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case FORM:
if (formPointer != null || isTemplateContents()) {
errFormWhenFormOpen();
break starttagloop;
} else {
errStartTagInTable(name);
appendVoidFormToCurrent(attributes);
attributes = null; // CPP
break starttagloop;
}
default:
errStartTagInTable(name);
// fall through to IN_BODY
break intableloop;
}
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_CAPTION:
switch (group) {
case CAPTION:
case COL:
case COLGROUP:
case TBODY_OR_THEAD_OR_TFOOT:
case TR:
case TD_OR_TH:
eltPos = findLastInTableScope("caption");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment || isTemplateContents();
errStrayStartTag(name);
break starttagloop;
}
generateImpliedEndTags();
if (errorHandler != null && currentPtr != eltPos) {
errNoCheckUnclosedElementsOnStack();
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
mode = IN_TABLE;
continue;
default:
// fall through to IN_BODY
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_CELL:
switch (group) {
case CAPTION:
case COL:
case COLGROUP:
case TBODY_OR_THEAD_OR_TFOOT:
case TR:
case TD_OR_TH:
eltPos = findLastInTableScopeTdTh();
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errNoCellToClose();
break starttagloop;
} else {
closeTheCell(eltPos);
continue;
}
default:
// fall through to IN_BODY
}
// CPPONLY: MOZ_FALLTHROUGH;
case FRAMESET_OK:
switch (group) {
case FRAMESET:
if (mode == FRAMESET_OK) {
if (currentPtr == 0 || stack[1].getGroup() != BODY) {
assert fragment || isTemplateContents();
errStrayStartTag(name);
break starttagloop;
} else {
errFramesetStart();
detachFromParent(stack[1].node);
while (currentPtr > 0) {
pop();
}
appendToCurrentNodeAndPushElement(
elementName,
attributes);
mode = IN_FRAMESET;
attributes = null; // CPP
break starttagloop;
}
} else {
errStrayStartTag(name);
break starttagloop;
}
// NOT falling through!
case PRE_OR_LISTING:
case LI:
case DD_OR_DT:
case BUTTON:
case MARQUEE_OR_APPLET:
case OBJECT:
case TABLE:
case AREA_OR_WBR:
case KEYGEN:
case BR:
case EMBED:
case IMG:
case INPUT:
case HR:
case TEXTAREA:
case XMP:
case IFRAME:
case SELECT:
if (mode == FRAMESET_OK
&& !(group == INPUT && Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"hidden",
attributes.getValue(AttributeName.TYPE)))) {
framesetOk = false;
mode = IN_BODY;
}
// CPPONLY: MOZ_FALLTHROUGH;
default:
// fall through to IN_BODY
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_BODY:
inbodyloop: for (;;) {
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case BASE:
case LINK_OR_BASEFONT_OR_BGSOUND:
case META:
case STYLE:
case SCRIPT:
case TITLE:
case TEMPLATE:
// Fall through to IN_HEAD
break inbodyloop;
case BODY:
if (currentPtr == 0 || stack[1].getGroup() != BODY || isTemplateContents()) {
assert fragment || isTemplateContents();
errStrayStartTag(name);
break starttagloop;
}
errFooSeenWhenFooOpen(name);
framesetOk = false;
if (mode == FRAMESET_OK) {
mode = IN_BODY;
}
if (addAttributesToBody(attributes)) {
attributes = null; // CPP
}
break starttagloop;
case P:
case DIV_OR_BLOCKQUOTE_OR_CENTER_OR_MENU:
case UL_OR_OL_OR_DL:
case ADDRESS_OR_ARTICLE_OR_ASIDE_OR_DETAILS_OR_DIALOG_OR_DIR_OR_FIGCAPTION_OR_FIGURE_OR_FOOTER_OR_HEADER_OR_HGROUP_OR_MAIN_OR_NAV_OR_SEARCH_OR_SECTION_OR_SUMMARY:
implicitlyCloseP();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case H1_OR_H2_OR_H3_OR_H4_OR_H5_OR_H6:
implicitlyCloseP();
if (stack[currentPtr].getGroup() == H1_OR_H2_OR_H3_OR_H4_OR_H5_OR_H6) {
errHeadingWhenHeadingOpen();
pop();
}
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case FIELDSET:
implicitlyCloseP();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes, formPointer);
attributes = null; // CPP
break starttagloop;
case PRE_OR_LISTING:
implicitlyCloseP();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
needToDropLF = true;
attributes = null; // CPP
break starttagloop;
case FORM:
if (formPointer != null && !isTemplateContents()) {
errFormWhenFormOpen();
break starttagloop;
} else {
implicitlyCloseP();
appendToCurrentNodeAndPushFormElementMayFoster(attributes);
attributes = null; // CPP
break starttagloop;
}
case LI:
case DD_OR_DT:
eltPos = currentPtr;
for (;;) {
StackNode<T> node = stack[eltPos]; // weak
// ref
if (node.getGroup() == group) { // LI or
// DD_OR_DT
generateImpliedEndTagsExceptFor(node.name);
if (errorHandler != null
&& eltPos != currentPtr) {
errUnclosedElementsImplied(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
break;
} else if (eltPos == 0 || (node.isSpecial()
&& (node.ns != "http://www.w3.org/1999/xhtml"
|| (node.name != "p"
&& node.name != "address"
&& node.name != "div")))) {
break;
}
eltPos--;
}
implicitlyCloseP();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case PLAINTEXT:
implicitlyCloseP();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
tokenizer.setStateAndEndTagExpectation(
Tokenizer.PLAINTEXT, elementName);
attributes = null; // CPP
break starttagloop;
case A:
int activeAPos = findInListOfActiveFormattingElementsContainsBetweenEndAndLastMarker("a");
if (activeAPos != -1) {
errFooSeenWhenFooOpen(name);
StackNode<T> activeA = listOfActiveFormattingElements[activeAPos];
activeA.retain();
adoptionAgencyEndTag("a");
removeFromStack(activeA);
activeAPos = findInListOfActiveFormattingElements(activeA);
if (activeAPos != -1) {
removeFromListOfActiveFormattingElements(activeAPos);
}
activeA.release(this);
}
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushFormattingElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case B_OR_BIG_OR_CODE_OR_EM_OR_I_OR_S_OR_SMALL_OR_STRIKE_OR_STRONG_OR_TT_OR_U:
case FONT:
reconstructTheActiveFormattingElements();
maybeForgetEarlierDuplicateFormattingElement(elementName.getName(), attributes);
appendToCurrentNodeAndPushFormattingElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case NOBR:
reconstructTheActiveFormattingElements();
if (TreeBuilder.NOT_FOUND_ON_STACK != findLastInScope("nobr")) {
errFooSeenWhenFooOpen(name);
adoptionAgencyEndTag("nobr");
reconstructTheActiveFormattingElements();
}
appendToCurrentNodeAndPushFormattingElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case BUTTON:
eltPos = findLastInScope(name);
if (eltPos != TreeBuilder.NOT_FOUND_ON_STACK) {
errFooSeenWhenFooOpen(name);
generateImpliedEndTags();
if (errorHandler != null
&& !isCurrent(name)) {
errUnclosedElementsImplied(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
continue starttagloop;
} else {
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes, formPointer);
attributes = null; // CPP
break starttagloop;
}
case OBJECT:
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes, formPointer);
insertMarker();
attributes = null; // CPP
break starttagloop;
case MARQUEE_OR_APPLET:
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
insertMarker();
attributes = null; // CPP
break starttagloop;
case TABLE:
// The only quirk. Blame Hixie and
// Acid2.
if (!quirks) {
implicitlyCloseP();
}
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
mode = IN_TABLE;
attributes = null; // CPP
break starttagloop;
case BR:
case EMBED:
case AREA_OR_WBR:
case KEYGEN:
reconstructTheActiveFormattingElements();
// FALL THROUGH to PARAM_OR_SOURCE_OR_TRACK
// CPPONLY: MOZ_FALLTHROUGH;
case PARAM_OR_SOURCE_OR_TRACK:
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case HR:
implicitlyCloseP();
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case IMAGE:
errImage();
elementName = ElementName.IMG;
continue starttagloop;
case IMG:
case INPUT:
reconstructTheActiveFormattingElements();
appendVoidElementToCurrentMayFoster(
elementName, attributes,
formPointer);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case TEXTAREA:
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes, formPointer);
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RCDATA, elementName);
originalMode = mode;
mode = TEXT;
needToDropLF = true;
attributes = null; // CPP
break starttagloop;
case XMP:
implicitlyCloseP();
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RAWTEXT, elementName);
attributes = null; // CPP
break starttagloop;
case NOSCRIPT:
if (!scriptingEnabled) {
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
}
// CPPONLY: MOZ_FALLTHROUGH;
case NOFRAMES:
case IFRAME:
case NOEMBED:
startTagGenericRawText(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case SELECT:
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes, formPointer);
switch (mode) {
case IN_TABLE:
case IN_CAPTION:
case IN_COLUMN_GROUP:
case IN_TABLE_BODY:
case IN_ROW:
case IN_CELL:
mode = IN_SELECT_IN_TABLE;
break;
default:
mode = IN_SELECT;
break;
}
attributes = null; // CPP
break starttagloop;
case OPTGROUP:
case OPTION:
if (isCurrent("option")) {
pop();
}
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case RB_OR_RTC:
eltPos = findLastInScope("ruby");
if (eltPos != NOT_FOUND_ON_STACK) {
generateImpliedEndTags();
}
if (eltPos != currentPtr) {
if (eltPos == NOT_FOUND_ON_STACK) {
errStartTagSeenWithoutRuby(name);
} else {
errUnclosedChildrenInRuby();
}
}
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case RT_OR_RP:
eltPos = findLastInScope("ruby");
if (eltPos != NOT_FOUND_ON_STACK) {
generateImpliedEndTagsExceptFor("rtc");
}
if (eltPos != currentPtr) {
if (!isCurrent("rtc")) {
if (eltPos == NOT_FOUND_ON_STACK) {
errStartTagSeenWithoutRuby(name);
} else {
errUnclosedChildrenInRuby();
}
}
}
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case MATH:
reconstructTheActiveFormattingElements();
attributes.adjustForMath();
if (selfClosing) {
appendVoidElementToCurrentMayFosterMathML(
elementName, attributes);
selfClosing = false;
} else {
appendToCurrentNodeAndPushElementMayFosterMathML(
elementName, attributes);
}
attributes = null; // CPP
break starttagloop;
case SVG:
reconstructTheActiveFormattingElements();
attributes.adjustForSvg();
if (selfClosing) {
appendVoidElementToCurrentMayFosterSVG(
elementName,
attributes);
selfClosing = false;
} else {
appendToCurrentNodeAndPushElementMayFosterSVG(
elementName, attributes);
}
attributes = null; // CPP
break starttagloop;
case CAPTION:
case COL:
case COLGROUP:
case TBODY_OR_THEAD_OR_TFOOT:
case TR:
case TD_OR_TH:
case FRAME:
case FRAMESET:
case HEAD:
errStrayStartTag(name);
break starttagloop;
case OUTPUT:
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes, formPointer);
attributes = null; // CPP
break starttagloop;
default:
reconstructTheActiveFormattingElements();
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
}
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_HEAD:
inheadloop: for (;;) {
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case BASE:
case LINK_OR_BASEFONT_OR_BGSOUND:
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case META:
// Fall through to IN_HEAD_NOSCRIPT
break inheadloop;
case TITLE:
startTagTitleInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case NOSCRIPT:
if (scriptingEnabled) {
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RAWTEXT, elementName);
} else {
appendToCurrentNodeAndPushElementMayFoster(
elementName,
attributes);
mode = IN_HEAD_NOSCRIPT;
}
attributes = null; // CPP
break starttagloop;
case SCRIPT:
startTagScriptInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case STYLE:
case NOFRAMES:
startTagGenericRawText(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case HEAD:
/* Parse error. */
errFooSeenWhenFooOpen(name);
/* Ignore the token. */
break starttagloop;
case TEMPLATE:
startTagTemplateInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
default:
pop();
mode = AFTER_HEAD;
continue starttagloop;
}
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_HEAD_NOSCRIPT:
switch (group) {
case HTML:
// XXX did Hixie really mean to omit "base"
// here?
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case LINK_OR_BASEFONT_OR_BGSOUND:
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case META:
checkMetaCharset(attributes);
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case STYLE:
case NOFRAMES:
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RAWTEXT, elementName);
attributes = null; // CPP
break starttagloop;
case HEAD:
errFooSeenWhenFooOpen(name);
break starttagloop;
case NOSCRIPT:
errFooSeenWhenFooOpen(name);
break starttagloop;
default:
errBadStartTagInNoscriptInHead(name);
pop();
mode = IN_HEAD;
continue;
}
case IN_COLUMN_GROUP:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case COL:
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
case TEMPLATE:
startTagTemplateInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
default:
if (currentPtr == 0 || stack[currentPtr].getGroup() == TEMPLATE) {
assert fragment || isTemplateContents();
errGarbageInColgroup();
break starttagloop;
}
pop();
mode = IN_TABLE;
continue;
}
case IN_SELECT_IN_TABLE:
switch (group) {
case CAPTION:
case TBODY_OR_THEAD_OR_TFOOT:
case TR:
case TD_OR_TH:
case TABLE:
errStartTagWithSelectOpen(name);
eltPos = findLastInTableScope("select");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment;
}
while (currentPtr >= eltPos) {
pop();
}
resetTheInsertionMode();
continue;
default:
// fall through to IN_SELECT
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_SELECT:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case OPTION:
if (isCurrent("option")) {
pop();
}
appendToCurrentNodeAndPushElement(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case OPTGROUP:
if (isCurrent("option")) {
pop();
}
if (isCurrent("optgroup")) {
pop();
}
appendToCurrentNodeAndPushElement(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case SELECT:
errStartSelectWhereEndSelectExpected();
eltPos = findLastInTableScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment;
errNoSelectInTableScope();
break starttagloop;
} else {
while (currentPtr >= eltPos) {
pop();
}
resetTheInsertionMode();
break starttagloop;
}
case INPUT:
case TEXTAREA:
errStartTagWithSelectOpen(name);
eltPos = findLastInTableScope("select");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment;
break starttagloop;
}
while (currentPtr >= eltPos) {
pop();
}
resetTheInsertionMode();
continue;
case SCRIPT:
startTagScriptInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case TEMPLATE:
startTagTemplateInHead(elementName, attributes);
attributes = null; // CPP
break starttagloop;
case HR:
if (isCurrent("option")) {
pop();
}
if (isCurrent("optgroup")) {
pop();
}
appendVoidElementToCurrent(elementName, attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
default:
errStrayStartTag(name);
break starttagloop;
}
case AFTER_BODY:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
default:
errStrayStartTag(name);
mode = framesetOk ? FRAMESET_OK : IN_BODY;
continue;
}
case IN_FRAMESET:
switch (group) {
case FRAMESET:
appendToCurrentNodeAndPushElement(
elementName,
attributes);
attributes = null; // CPP
break starttagloop;
case FRAME:
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
attributes = null; // CPP
break starttagloop;
default:
// fall through to AFTER_FRAMESET
}
// CPPONLY: MOZ_FALLTHROUGH;
case AFTER_FRAMESET:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case NOFRAMES:
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RAWTEXT, elementName);
attributes = null; // CPP
break starttagloop;
default:
errStrayStartTag(name);
break starttagloop;
}
case INITIAL:
/*
* Parse error.
*/
errStartTagWithoutDoctype();
/*
*
* Set the document to quirks mode.
*/
documentModeInternal(DocumentMode.QUIRKS_MODE, null, null);
/*
* Then, switch to the root element mode of the tree
* construction stage
*/
mode = BEFORE_HTML;
/*
* and reprocess the current token.
*/
continue;
case BEFORE_HTML:
switch (group) {
case HTML:
// optimize error check and streaming SAX by
// hoisting
// "html" handling here.
if (attributes == HtmlAttributes.EMPTY_ATTRIBUTES) {
// This has the right magic side effect
// that
// it
// makes attributes in SAX Tree mutable.
appendHtmlElementToDocumentAndPush();
} else {
appendHtmlElementToDocumentAndPush(attributes);
}
// XXX application cache should fire here
mode = BEFORE_HEAD;
attributes = null; // CPP
break starttagloop;
default:
/*
* Create an HTMLElement node with the tag name
* html, in the HTML namespace. Append it to the
* Document object.
*/
appendHtmlElementToDocumentAndPush();
/* Switch to the main mode */
mode = BEFORE_HEAD;
/*
* reprocess the current token.
*/
continue;
}
case BEFORE_HEAD:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case HEAD:
/*
* A start tag whose tag name is "head"
*
* 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.
*/
appendToCurrentNodeAndPushHeadElement(attributes);
/*
* Change the insertion mode to "in head".
*/
mode = IN_HEAD;
attributes = null; // CPP
break starttagloop;
default:
/*
* Any other start tag token
*
* Act as if a start tag token with the tag name
* "head" and no attributes had been seen,
*/
appendToCurrentNodeAndPushHeadElement(HtmlAttributes.EMPTY_ATTRIBUTES);
mode = IN_HEAD;
/*
* 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.
*/
continue;
}
case AFTER_HEAD:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case BODY:
if (attributes.getLength() == 0) {
// This has the right magic side effect
// that
// it
// makes attributes in SAX Tree mutable.
appendToCurrentNodeAndPushBodyElement();
} else {
appendToCurrentNodeAndPushBodyElement(attributes);
}
framesetOk = false;
mode = IN_BODY;
attributes = null; // CPP
break starttagloop;
case FRAMESET:
appendToCurrentNodeAndPushElement(
elementName,
attributes);
mode = IN_FRAMESET;
attributes = null; // CPP
break starttagloop;
case TEMPLATE:
errFooBetweenHeadAndBody(name);
pushHeadPointerOntoStack();
StackNode<T> headOnStack = stack[currentPtr];
startTagTemplateInHead(elementName, attributes);
removeFromStack(headOnStack);
attributes = null; // CPP
break starttagloop;
case BASE:
case LINK_OR_BASEFONT_OR_BGSOUND:
errFooBetweenHeadAndBody(name);
pushHeadPointerOntoStack();
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
pop(); // head
attributes = null; // CPP
break starttagloop;
case META:
errFooBetweenHeadAndBody(name);
checkMetaCharset(attributes);
pushHeadPointerOntoStack();
appendVoidElementToCurrentMayFoster(
elementName,
attributes);
selfClosing = false;
// [NOCPP[
voidElement = true;
// ]NOCPP]
pop(); // head
attributes = null; // CPP
break starttagloop;
case SCRIPT:
errFooBetweenHeadAndBody(name);
pushHeadPointerOntoStack();
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.SCRIPT_DATA, elementName);
attributes = null; // CPP
break starttagloop;
case STYLE:
case NOFRAMES:
errFooBetweenHeadAndBody(name);
pushHeadPointerOntoStack();
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RAWTEXT, elementName);
attributes = null; // CPP
break starttagloop;
case TITLE:
errFooBetweenHeadAndBody(name);
pushHeadPointerOntoStack();
appendToCurrentNodeAndPushElement(
elementName,
attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(
Tokenizer.RCDATA, elementName);
attributes = null; // CPP
break starttagloop;
case HEAD:
errStrayStartTag(name);
break starttagloop;
default:
appendToCurrentNodeAndPushBodyElement();
mode = FRAMESET_OK;
continue;
}
case AFTER_AFTER_BODY:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
default:
errStrayStartTag(name);
fatal();
mode = framesetOk ? FRAMESET_OK : IN_BODY;
continue;
}
case AFTER_AFTER_FRAMESET:
switch (group) {
case HTML:
errStrayStartTag(name);
if (!fragment && !isTemplateContents()) {
addAttributesToHtml(attributes);
attributes = null; // CPP
}
break starttagloop;
case NOFRAMES:
startTagGenericRawText(elementName, attributes);
attributes = null; // CPP
break starttagloop;
default:
errStrayStartTag(name);
break starttagloop;
}
case TEXT:
assert false;
break starttagloop; // Avoid infinite loop if the assertion
// fails
}
}
if (selfClosing) {
errSelfClosing();
// [NOCPP[
} else if (wasSelfClosing && voidElement
&& tokenizer.getErrorProfile() != null
&& tokenizer.getErrorProfile().get("html-strict") != null) {
warn("Trailing slash on void elements has no effect and interacts"
+ " badly with unquoted attribute values.");
// ]NOCPP]
}
// CPPONLY: if (mBuilder == null && attributes != HtmlAttributes.EMPTY_ATTRIBUTES) {
// CPPONLY: Portability.delete(attributes);
// CPPONLY: }
}
private void startTagTitleInHead(ElementName elementName, HtmlAttributes attributes) throws SAXException {
appendToCurrentNodeAndPushElementMayFoster(elementName, attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(Tokenizer.RCDATA, elementName);
}
private void startTagGenericRawText(ElementName elementName, HtmlAttributes attributes) throws SAXException {
appendToCurrentNodeAndPushElementMayFoster(elementName, attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(Tokenizer.RAWTEXT, elementName);
}
private void startTagScriptInHead(ElementName elementName, HtmlAttributes attributes) throws SAXException {
// XXX need to manage much more stuff here if supporting document.write()
appendToCurrentNodeAndPushElementMayFoster(elementName, attributes);
originalMode = mode;
mode = TEXT;
tokenizer.setStateAndEndTagExpectation(Tokenizer.SCRIPT_DATA, elementName);
}
private void startTagTemplateInHead(ElementName elementName, HtmlAttributes attributes) throws SAXException {
appendToCurrentNodeAndPushElement(elementName, attributes);
insertMarker();
framesetOk = false;
originalMode = mode;
mode = IN_TEMPLATE;
pushTemplateMode(IN_TEMPLATE);
}
private boolean isTemplateContents() {
return TreeBuilder.NOT_FOUND_ON_STACK != findLast("template");
}
private boolean isTemplateModeStackEmpty() {
return templateModePtr == -1;
}
private boolean isSpecialParentInForeign(StackNode<T> stackNode) {
@NsUri String ns = stackNode.ns;
return ("http://www.w3.org/1999/xhtml" == ns)
|| (stackNode.isHtmlIntegrationPoint())
|| (("http://www.w3.org/1998/Math/MathML" == ns) && (stackNode.getGroup() == MI_MO_MN_MS_MTEXT));
}
private T getDeclarativeShadowRoot(T currentNode, T templateNode, HtmlAttributes attributes) {
if (!isAllowDeclarativeShadowRoots()) {
return null;
}
String shadowRootMode = attributes.getValue(AttributeName.SHADOWROOTMODE);
if (shadowRootMode == null) {
return null;
}
boolean shadowRootIsClonable = attributes.contains(AttributeName.SHADOWROOTCLONABLE);
boolean shadowRootDelegatesFocus = attributes.contains(AttributeName.SHADOWROOTDELEGATESFOCUS);
return getShadowRootFromHost(currentNode, templateNode, shadowRootMode, shadowRootIsClonable, shadowRootDelegatesFocus);
}
/**
*
* <p>
* C++ memory note: The return value must be released.
*
* @return
* @throws SAXException
* @throws StopSniffingException
*/
public static String extractCharsetFromContent(String attributeValue
// CPPONLY: , TreeBuilder tb
) {
// This is a bit ugly. Converting the string to char array in order to
// make the portability layer smaller.
int charsetState = CHARSET_INITIAL;
int start = -1;
int end = -1;
@Auto char[] buffer = Portability.newCharArrayFromString(attributeValue);
charsetloop: for (int i = 0; i < buffer.length; i++) {
char c = buffer[i];
switch (charsetState) {
case CHARSET_INITIAL:
switch (c) {
case 'c':
case 'C':
charsetState = CHARSET_C;
continue;
default:
continue;
}
case CHARSET_C:
switch (c) {
case 'h':
case 'H':
charsetState = CHARSET_H;
continue;
default:
charsetState = CHARSET_INITIAL;
continue;
}
case CHARSET_H:
switch (c) {
case 'a':
case 'A':
charsetState = CHARSET_A;
continue;
default:
charsetState = CHARSET_INITIAL;
continue;
}
case CHARSET_A:
switch (c) {
case 'r':
case 'R':
charsetState = CHARSET_R;
continue;
default:
charsetState = CHARSET_INITIAL;
continue;
}
case CHARSET_R:
switch (c) {
case 's':
case 'S':
charsetState = CHARSET_S;
continue;
default:
charsetState = CHARSET_INITIAL;
continue;
}
case CHARSET_S:
switch (c) {
case 'e':
case 'E':
charsetState = CHARSET_E;
continue;
default:
charsetState = CHARSET_INITIAL;
continue;
}
case CHARSET_E:
switch (c) {
case 't':
case 'T':
charsetState = CHARSET_T;
continue;
default:
charsetState = CHARSET_INITIAL;
continue;
}
case CHARSET_T:
switch (c) {
case '\t':
case '\n':
case '\u000C':
case '\r':
case ' ':
continue;
case '=':
charsetState = CHARSET_EQUALS;
continue;
default:
return null;
}
case CHARSET_EQUALS:
switch (c) {
case '\t':
case '\n':
case '\u000C':
case '\r':
case ' ':
continue;
case '\'':
start = i + 1;
charsetState = CHARSET_SINGLE_QUOTED;
continue;
case '\"':
start = i + 1;
charsetState = CHARSET_DOUBLE_QUOTED;
continue;
default:
start = i;
charsetState = CHARSET_UNQUOTED;
continue;
}
case CHARSET_SINGLE_QUOTED:
switch (c) {
case '\'':
end = i;
break charsetloop;
default:
continue;
}
case CHARSET_DOUBLE_QUOTED:
switch (c) {
case '\"':
end = i;
break charsetloop;
default:
continue;
}
case CHARSET_UNQUOTED:
switch (c) {
case '\t':
case '\n':
case '\u000C':
case '\r':
case ' ':
case ';':
end = i;
break charsetloop;
default:
continue;
}
}
}
if (start != -1) {
if (end == -1) {
if (charsetState == CHARSET_UNQUOTED) {
end = buffer.length;
} else {
return null;
}
}
return Portability.newStringFromBuffer(buffer, start, end
- start
// CPPONLY: , tb, false
);
}
return null;
}
private void checkMetaCharset(HtmlAttributes attributes)
throws SAXException {
String charset = attributes.getValue(AttributeName.CHARSET);
if (charset != null) {
if (tokenizer.internalEncodingDeclaration(charset)) {
requestSuspension();
return;
}
return;
}
if (!Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"content-type",
attributes.getValue(AttributeName.HTTP_EQUIV))) {
return;
}
String content = attributes.getValue(AttributeName.CONTENT);
if (content != null) {
String extract = TreeBuilder.extractCharsetFromContent(content
// CPPONLY: , this
);
// remember not to return early without releasing the string
if (extract != null) {
if (tokenizer.internalEncodingDeclaration(extract)) {
requestSuspension();
}
}
Portability.releaseString(extract);
}
}
public final void endTag(ElementName elementName) throws SAXException {
flushCharacters();
needToDropLF = false;
int eltPos;
int group = elementName.getGroup();
@Local String name = elementName.getName();
endtagloop: for (;;) {
if (isInForeign()) {
if (stack[currentPtr].name != name) {
if (currentPtr == 0) {
errStrayEndTag(name);
} else {
errEndTagDidNotMatchCurrentOpenElement(name, stack[currentPtr].popName);
}
}
eltPos = currentPtr;
int origPos = currentPtr;
for (;;) {
if (eltPos == 0) {
assert fragment: "We can get this close to the root of the stack in foreign content only in the fragment case.";
break endtagloop;
}
if (stack[eltPos].name == name) {
while (currentPtr >= eltPos) {
popForeign(origPos, eltPos);
}
break endtagloop;
}
if (stack[--eltPos].ns == "http://www.w3.org/1999/xhtml") {
break;
}
}
}
switch (mode) {
case IN_TEMPLATE:
switch (group) {
case TEMPLATE:
// fall through to IN_HEAD
break;
default:
errStrayEndTag(name);
break endtagloop;
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_ROW:
switch (group) {
case TR:
eltPos = findLastOrRoot(TreeBuilder.TR);
if (eltPos == 0) {
assert fragment || isTemplateContents();
errNoTableRowToClose();
break endtagloop;
}
clearStackBackTo(eltPos);
pop();
mode = IN_TABLE_BODY;
break endtagloop;
case TABLE:
eltPos = findLastOrRoot(TreeBuilder.TR);
if (eltPos == 0) {
assert fragment || isTemplateContents();
errNoTableRowToClose();
break endtagloop;
}
clearStackBackTo(eltPos);
pop();
mode = IN_TABLE_BODY;
continue;
case TBODY_OR_THEAD_OR_TFOOT:
if (findLastInTableScope(name) == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag(name);
break endtagloop;
}
eltPos = findLastOrRoot(TreeBuilder.TR);
if (eltPos == 0) {
assert fragment || isTemplateContents();
errNoTableRowToClose();
break endtagloop;
}
clearStackBackTo(eltPos);
pop();
mode = IN_TABLE_BODY;
continue;
case BODY:
case CAPTION:
case COL:
case COLGROUP:
case HTML:
case TD_OR_TH:
errStrayEndTag(name);
break endtagloop;
default:
// fall through to IN_TABLE
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_TABLE_BODY:
switch (group) {
case TBODY_OR_THEAD_OR_TFOOT:
eltPos = findLastOrRoot(name);
if (eltPos == 0) {
errStrayEndTag(name);
break endtagloop;
}
clearStackBackTo(eltPos);
pop();
mode = IN_TABLE;
break endtagloop;
case TABLE:
eltPos = findLastInTableScopeOrRootTemplateTbodyTheadTfoot();
if (eltPos == 0 || stack[eltPos].getGroup() == TEMPLATE) {
assert fragment || isTemplateContents();
errStrayEndTag(name);
break endtagloop;
}
clearStackBackTo(eltPos);
pop();
mode = IN_TABLE;
continue;
case BODY:
case CAPTION:
case COL:
case COLGROUP:
case HTML:
case TD_OR_TH:
case TR:
errStrayEndTag(name);
break endtagloop;
default:
// fall through to IN_TABLE
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_TABLE:
switch (group) {
case TABLE:
eltPos = findLast("table");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment || isTemplateContents();
errStrayEndTag(name);
break endtagloop;
}
while (currentPtr >= eltPos) {
pop();
}
resetTheInsertionMode();
break endtagloop;
case BODY:
case CAPTION:
case COL:
case COLGROUP:
case HTML:
case TBODY_OR_THEAD_OR_TFOOT:
case TD_OR_TH:
case TR:
errStrayEndTag(name);
break endtagloop;
case TEMPLATE:
// fall through to IN_HEAD
break;
default:
errStrayEndTag(name);
// fall through to IN_BODY
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_CAPTION:
switch (group) {
case CAPTION:
eltPos = findLastInTableScope("caption");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
break endtagloop;
}
generateImpliedEndTags();
if (errorHandler != null && currentPtr != eltPos) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
mode = IN_TABLE;
break endtagloop;
case TABLE:
eltPos = findLastInTableScope("caption");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment || isTemplateContents();
errStrayEndTag(name);
break endtagloop;
}
generateImpliedEndTags();
if (errorHandler != null && currentPtr != eltPos) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
mode = IN_TABLE;
continue;
case BODY:
case COL:
case COLGROUP:
case HTML:
case TBODY_OR_THEAD_OR_TFOOT:
case TD_OR_TH:
case TR:
errStrayEndTag(name);
break endtagloop;
default:
// fall through to IN_BODY
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_CELL:
switch (group) {
case TD_OR_TH:
eltPos = findLastInTableScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag(name);
break endtagloop;
}
generateImpliedEndTags();
if (errorHandler != null && !isCurrent(name)) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
mode = IN_ROW;
break endtagloop;
case TABLE:
case TBODY_OR_THEAD_OR_TFOOT:
case TR:
if (findLastInTableScope(name) == TreeBuilder.NOT_FOUND_ON_STACK) {
assert name == "tbody" || name == "tfoot" || name == "thead" || fragment || isTemplateContents();
errStrayEndTag(name);
break endtagloop;
}
closeTheCell(findLastInTableScopeTdTh());
continue;
case BODY:
case CAPTION:
case COL:
case COLGROUP:
case HTML:
errStrayEndTag(name);
break endtagloop;
default:
// fall through to IN_BODY
}
// CPPONLY: MOZ_FALLTHROUGH;
case FRAMESET_OK:
case IN_BODY:
switch (group) {
case BODY:
if (!isSecondOnStackBody()) {
assert fragment || isTemplateContents();
errStrayEndTag(name);
break endtagloop;
}
assert currentPtr >= 1;
if (errorHandler != null) {
uncloseloop1: for (int i = 2; i <= currentPtr; i++) {
switch (stack[i].getGroup()) {
case DD_OR_DT:
case LI:
case OPTGROUP:
case OPTION: // is this possible?
case P:
case RB_OR_RTC:
case RT_OR_RP:
case TD_OR_TH:
case TBODY_OR_THEAD_OR_TFOOT:
break;
default:
errEndWithUnclosedElements(name);
break uncloseloop1;
}
}
}
mode = AFTER_BODY;
break endtagloop;
case HTML:
if (!isSecondOnStackBody()) {
assert fragment || isTemplateContents();
errStrayEndTag(name);
break endtagloop;
}
if (errorHandler != null) {
uncloseloop2: for (int i = 0; i <= currentPtr; i++) {
switch (stack[i].getGroup()) {
case DD_OR_DT:
case LI:
case P:
case RB_OR_RTC:
case RT_OR_RP:
case TBODY_OR_THEAD_OR_TFOOT:
case TD_OR_TH:
case BODY:
case HTML:
break;
default:
errEndWithUnclosedElements(name);
break uncloseloop2;
}
}
}
mode = AFTER_BODY;
continue;
case DIV_OR_BLOCKQUOTE_OR_CENTER_OR_MENU:
case UL_OR_OL_OR_DL:
case PRE_OR_LISTING:
case FIELDSET:
case BUTTON:
case ADDRESS_OR_ARTICLE_OR_ASIDE_OR_DETAILS_OR_DIALOG_OR_DIR_OR_FIGCAPTION_OR_FIGURE_OR_FOOTER_OR_HEADER_OR_HGROUP_OR_MAIN_OR_NAV_OR_SEARCH_OR_SECTION_OR_SUMMARY:
eltPos = findLastInScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag(name);
} else {
generateImpliedEndTags();
if (errorHandler != null && !isCurrent(name)) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
}
break endtagloop;
case FORM:
if (!isTemplateContents()) {
if (formPointer == null) {
errStrayEndTag(name);
break endtagloop;
}
formPointer = null;
eltPos = findLastInScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag(name);
break endtagloop;
}
generateImpliedEndTags();
if (errorHandler != null && !isCurrent(name)) {
errUnclosedElements(eltPos, name);
}
removeFromStack(eltPos);
break endtagloop;
} else {
eltPos = findLastInScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag(name);
break endtagloop;
}
generateImpliedEndTags();
if (errorHandler != null && !isCurrent(name)) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
break endtagloop;
}
case P:
eltPos = findLastInButtonScope("p");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errNoElementToCloseButEndTagSeen("p");
// XXX Can the 'in foreign' case happen anymore?
if (isInForeign()) {
errHtmlStartTagInForeignContext(name);
// Check for currentPtr for the fragment
// case.
while (currentPtr >= 0 && stack[currentPtr].ns != "http://www.w3.org/1999/xhtml") {
pop();
}
}
appendVoidElementToCurrentMayFoster(
elementName,
HtmlAttributes.EMPTY_ATTRIBUTES);
break endtagloop;
}
generateImpliedEndTagsExceptFor("p");
assert eltPos != TreeBuilder.NOT_FOUND_ON_STACK;
if (errorHandler != null && eltPos != currentPtr) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
break endtagloop;
case LI:
eltPos = findLastInListScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errNoElementToCloseButEndTagSeen(name);
} else {
generateImpliedEndTagsExceptFor(name);
if (errorHandler != null
&& eltPos != currentPtr) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
}
break endtagloop;
case DD_OR_DT:
eltPos = findLastInScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errNoElementToCloseButEndTagSeen(name);
} else {
generateImpliedEndTagsExceptFor(name);
if (errorHandler != null
&& eltPos != currentPtr) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
}
break endtagloop;
case H1_OR_H2_OR_H3_OR_H4_OR_H5_OR_H6:
eltPos = findLastInScopeHn();
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag(name);
} else {
generateImpliedEndTags();
if (errorHandler != null && !isCurrent(name)) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
}
break endtagloop;
case OBJECT:
case MARQUEE_OR_APPLET:
eltPos = findLastInScope(name);
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag(name);
} else {
generateImpliedEndTags();
if (errorHandler != null && !isCurrent(name)) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
}
break endtagloop;
case BR:
errEndTagBr();
if (isInForeign()) {
// XXX can this happen anymore?
errHtmlStartTagInForeignContext(name);
// Check for currentPtr for the fragment
// case.
while (currentPtr >= 0 && stack[currentPtr].ns != "http://www.w3.org/1999/xhtml") {
pop();
}
}
reconstructTheActiveFormattingElements();
appendVoidElementToCurrentMayFoster(
elementName,
HtmlAttributes.EMPTY_ATTRIBUTES);
break endtagloop;
case TEMPLATE:
// fall through to IN_HEAD;
break;
case AREA_OR_WBR:
case KEYGEN: // XXX??
case PARAM_OR_SOURCE_OR_TRACK:
case EMBED:
case IMG:
case IMAGE:
case INPUT:
case HR:
case IFRAME:
case NOEMBED: // XXX???
case NOFRAMES: // XXX??
case SELECT:
case TABLE:
case TEXTAREA: // XXX??
errStrayEndTag(name);
break endtagloop;
case NOSCRIPT:
if (scriptingEnabled) {
errStrayEndTag(name);
break endtagloop;
}
// CPPONLY: MOZ_FALLTHROUGH;
case A:
case B_OR_BIG_OR_CODE_OR_EM_OR_I_OR_S_OR_SMALL_OR_STRIKE_OR_STRONG_OR_TT_OR_U:
case FONT:
case NOBR:
if (adoptionAgencyEndTag(name)) {
break endtagloop;
}
// else handle like any other tag
// CPPONLY: MOZ_FALLTHROUGH;
default:
if (isCurrent(name)) {
pop();
break endtagloop;
}
eltPos = currentPtr;
for (;;) {
StackNode<T> node = stack[eltPos];
if (node.ns == "http://www.w3.org/1999/xhtml" && node.name == name) {
generateImpliedEndTags();
if (errorHandler != null
&& !isCurrent(name)) {
errUnclosedElements(eltPos, name);
}
while (currentPtr >= eltPos) {
pop();
}
break endtagloop;
} else if (eltPos == 0 || node.isSpecial()) {
errStrayEndTag(name);
break endtagloop;
}
eltPos--;
}
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_HEAD:
switch (group) {
case HEAD:
pop();
mode = AFTER_HEAD;
break endtagloop;
case BR:
case HTML:
case BODY:
pop();
mode = AFTER_HEAD;
continue;
case TEMPLATE:
endTagTemplateInHead();
break endtagloop;
default:
errStrayEndTag(name);
break endtagloop;
}
case IN_HEAD_NOSCRIPT:
switch (group) {
case NOSCRIPT:
pop();
mode = IN_HEAD;
break endtagloop;
case BR:
errStrayEndTag(name);
pop();
mode = IN_HEAD;
continue;
default:
errStrayEndTag(name);
break endtagloop;
}
case IN_COLUMN_GROUP:
switch (group) {
case COLGROUP:
if (currentPtr == 0 || stack[currentPtr].getGroup() ==
TreeBuilder.TEMPLATE) {
assert fragment || isTemplateContents();
errGarbageInColgroup();
break endtagloop;
}
pop();
mode = IN_TABLE;
break endtagloop;
case COL:
errStrayEndTag(name);
break endtagloop;
case TEMPLATE:
endTagTemplateInHead();
break endtagloop;
default:
if (currentPtr == 0 || stack[currentPtr].getGroup() ==
TreeBuilder.TEMPLATE) {
assert fragment || isTemplateContents();
errGarbageInColgroup();
break endtagloop;
}
pop();
mode = IN_TABLE;
continue;
}
case IN_SELECT_IN_TABLE:
switch (group) {
case CAPTION:
case TABLE:
case TBODY_OR_THEAD_OR_TFOOT:
case TR:
case TD_OR_TH:
errEndTagSeenWithSelectOpen(name);
if (findLastInTableScope(name) != TreeBuilder.NOT_FOUND_ON_STACK) {
eltPos = findLastInTableScope("select");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment;
}
while (currentPtr >= eltPos) {
pop();
}
resetTheInsertionMode();
continue;
} else {
break endtagloop;
}
default:
// fall through to IN_SELECT
}
// CPPONLY: MOZ_FALLTHROUGH;
case IN_SELECT:
switch (group) {
case OPTION:
if (isCurrent("option")) {
pop();
break endtagloop;
} else {
errStrayEndTag(name);
break endtagloop;
}
case OPTGROUP:
if (isCurrent("option")
&& "optgroup" == stack[currentPtr - 1].name) {
pop();
}
if (isCurrent("optgroup")) {
pop();
} else {
errStrayEndTag(name);
}
break endtagloop;
case SELECT:
eltPos = findLastInTableScope("select");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
assert fragment;
errStrayEndTag(name);
break endtagloop;
}
while (currentPtr >= eltPos) {
pop();
}
resetTheInsertionMode();
break endtagloop;
case TEMPLATE:
endTagTemplateInHead();
break endtagloop;
default:
errStrayEndTag(name);
break endtagloop;
}
case AFTER_BODY:
switch (group) {
case HTML:
if (fragment) {
errStrayEndTag(name);
break endtagloop;
} else {
mode = AFTER_AFTER_BODY;
break endtagloop;
}
default:
errEndTagAfterBody();
mode = framesetOk ? FRAMESET_OK : IN_BODY;
continue;
}
case IN_FRAMESET:
switch (group) {
case FRAMESET:
if (currentPtr == 0) {
assert fragment;
errStrayEndTag(name);
break endtagloop;
}
pop();
if ((!fragment) && !isCurrent("frameset")) {
mode = AFTER_FRAMESET;
}
break endtagloop;
default:
errStrayEndTag(name);
break endtagloop;
}
case AFTER_FRAMESET:
switch (group) {
case HTML:
mode = AFTER_AFTER_FRAMESET;
break endtagloop;
default:
errStrayEndTag(name);
break endtagloop;
}
case INITIAL:
/*
* Parse error.
*/
errEndTagSeenWithoutDoctype();
/*
*
* Set the document to quirks mode.
*/
documentModeInternal(DocumentMode.QUIRKS_MODE, null, null);
/*
* Then, switch to the root element mode of the tree
* construction stage
*/
mode = BEFORE_HTML;
/*
* and reprocess the current token.
*/
continue;
case BEFORE_HTML:
switch (group) {
case HEAD:
case BR:
case HTML:
case BODY:
/*
* Create an HTMLElement node with the tag name
* html, in the HTML namespace. Append it to the
* Document object.
*/
appendHtmlElementToDocumentAndPush();
/* Switch to the main mode */
mode = BEFORE_HEAD;
/*
* reprocess the current token.
*/
continue;
default:
errStrayEndTag(name);
break endtagloop;
}
case BEFORE_HEAD:
switch (group) {
case HEAD:
case BR:
case HTML:
case BODY:
appendToCurrentNodeAndPushHeadElement(HtmlAttributes.EMPTY_ATTRIBUTES);
mode = IN_HEAD;
continue;
default:
errStrayEndTag(name);
break endtagloop;
}
case AFTER_HEAD:
switch (group) {
case TEMPLATE:
endTagTemplateInHead();
break endtagloop;
case HTML:
case BODY:
case BR:
appendToCurrentNodeAndPushBodyElement();
mode = FRAMESET_OK;
continue;
default:
errStrayEndTag(name);
break endtagloop;
}
case AFTER_AFTER_BODY:
errStrayEndTag(name);
mode = framesetOk ? FRAMESET_OK : IN_BODY;
continue;
case AFTER_AFTER_FRAMESET:
errStrayEndTag(name);
break endtagloop;
case TEXT:
// XXX need to manage insertion point here
pop();
if (originalMode == AFTER_HEAD) {
silentPop();
}
mode = originalMode;
break endtagloop;
}
} // endtagloop
}
private void endTagTemplateInHead() throws SAXException {
int eltPos = findLast("template");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
errStrayEndTag("template");
return;
}
generateImpliedEndTagsThoroughly();
if (errorHandler != null && !isCurrent("template")) {
errUnclosedElements(eltPos, "template");
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
popTemplateMode();
resetTheInsertionMode();
}
private int findLastInTableScopeOrRootTemplateTbodyTheadTfoot() {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml"
&& (stack[i].getGroup() == TreeBuilder.TBODY_OR_THEAD_OR_TFOOT
|| stack[i].getGroup() == TreeBuilder.TEMPLATE)) {
return i;
}
}
return 0;
}
private int findLast(@Local String name) {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml" && stack[i].name == name) {
return i;
}
}
return TreeBuilder.NOT_FOUND_ON_STACK;
}
private int findLastInTableScope(@Local String name) {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml") {
if (stack[i].name == name) {
return i;
} else if (stack[i].name == "table" || stack[i].name == "template") {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
}
return TreeBuilder.NOT_FOUND_ON_STACK;
}
private int findLastInButtonScope(@Local String name) {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml") {
if (stack[i].name == name) {
return i;
} else if (stack[i].name == "button") {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
if (stack[i].isScoping()) {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
return TreeBuilder.NOT_FOUND_ON_STACK;
}
private int findLastInScope(@Local String name) {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml" && stack[i].name == name) {
return i;
} else if (stack[i].isScoping()) {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
return TreeBuilder.NOT_FOUND_ON_STACK;
}
private int findLastInListScope(@Local String name) {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml") {
if (stack[i].name == name) {
return i;
} else if (stack[i].name == "ul" || stack[i].name == "ol") {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
if (stack[i].isScoping()) {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
return TreeBuilder.NOT_FOUND_ON_STACK;
}
private int findLastInScopeHn() {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].getGroup() == TreeBuilder.H1_OR_H2_OR_H3_OR_H4_OR_H5_OR_H6) {
return i;
} else if (stack[i].isScoping()) {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
return TreeBuilder.NOT_FOUND_ON_STACK;
}
private void generateImpliedEndTagsExceptFor(@Local String name)
throws SAXException {
for (;;) {
StackNode<T> node = stack[currentPtr];
switch (node.getGroup()) {
case P:
case LI:
case DD_OR_DT:
case OPTION:
case OPTGROUP:
case RB_OR_RTC:
case RT_OR_RP:
if (node.ns == "http://www.w3.org/1999/xhtml" && node.name == name) {
return;
}
pop();
continue;
default:
return;
}
}
}
private void generateImpliedEndTags() throws SAXException {
for (;;) {
switch (stack[currentPtr].getGroup()) {
case P:
case LI:
case DD_OR_DT:
case OPTION:
case OPTGROUP:
case RB_OR_RTC:
case RT_OR_RP:
pop();
continue;
default:
return;
}
}
}
private void generateImpliedEndTagsThoroughly() throws SAXException {
for (;;) {
switch (stack[currentPtr].getGroup()) {
case CAPTION:
case COLGROUP:
case DD_OR_DT:
case LI:
case OPTGROUP:
case OPTION:
case P:
case RB_OR_RTC:
case RT_OR_RP:
case TBODY_OR_THEAD_OR_TFOOT:
case TD_OR_TH:
case TR:
pop();
continue;
default:
return;
}
}
}
private boolean isSecondOnStackBody() {
return currentPtr >= 1 && stack[1].getGroup() == TreeBuilder.BODY;
}
private void documentModeInternal(DocumentMode m, String publicIdentifier,
String systemIdentifier)
throws SAXException {
if (forceNoQuirks) {
// Srcdoc documents are always rendered in standards mode.
quirks = false;
if (documentModeHandler != null) {
documentModeHandler.documentMode(
DocumentMode.STANDARDS_MODE
// [NOCPP[
, null, null
// ]NOCPP]
);
}
return;
}
quirks = (m == DocumentMode.QUIRKS_MODE);
if (documentModeHandler != null) {
documentModeHandler.documentMode(
m
// [NOCPP[
, publicIdentifier, systemIdentifier
// ]NOCPP]
);
}
// [NOCPP[
documentMode(m, publicIdentifier, systemIdentifier);
// ]NOCPP]
}
private boolean isAlmostStandards(String publicIdentifier,
String systemIdentifier) {
if (Portability.lowerCaseLiteralIsPrefixOfIgnoreAsciiCaseString(
"-//w3c//dtd xhtml 1.0 transitional//", publicIdentifier)) {
return true;
}
if (Portability.lowerCaseLiteralIsPrefixOfIgnoreAsciiCaseString(
"-//w3c//dtd xhtml 1.0 frameset//", publicIdentifier)) {
return true;
}
if (systemIdentifier != null) {
if (Portability.lowerCaseLiteralIsPrefixOfIgnoreAsciiCaseString(
"-//w3c//dtd html 4.01 transitional//", publicIdentifier)) {
return true;
}
if (Portability.lowerCaseLiteralIsPrefixOfIgnoreAsciiCaseString(
"-//w3c//dtd html 4.01 frameset//", publicIdentifier)) {
return true;
}
}
return false;
}
private boolean isQuirky(@Local String name, String publicIdentifier,
String systemIdentifier, boolean forceQuirks) {
if (forceQuirks) {
return true;
}
if (name != HTML_LOCAL) {
return true;
}
if (publicIdentifier != null) {
for (int i = 0; i < TreeBuilder.QUIRKY_PUBLIC_IDS.length; i++) {
if (Portability.lowerCaseLiteralIsPrefixOfIgnoreAsciiCaseString(
TreeBuilder.QUIRKY_PUBLIC_IDS[i], publicIdentifier)) {
return true;
}
}
if (Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"-//w3o//dtd w3 html strict 3.0//en//", publicIdentifier)
|| Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"-/w3c/dtd html 4.0 transitional/en",
publicIdentifier)
|| Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"html", publicIdentifier)) {
return true;
}
}
if (systemIdentifier == null) {
if (Portability.lowerCaseLiteralIsPrefixOfIgnoreAsciiCaseString(
"-//w3c//dtd html 4.01 transitional//", publicIdentifier)) {
return true;
} else if (Portability.lowerCaseLiteralIsPrefixOfIgnoreAsciiCaseString(
"-//w3c//dtd html 4.01 frameset//", publicIdentifier)) {
return true;
}
} else if (Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
systemIdentifier)) {
return true;
}
return false;
}
private void closeTheCell(int eltPos) throws SAXException {
generateImpliedEndTags();
if (errorHandler != null && eltPos != currentPtr) {
errUnclosedElementsCell(eltPos);
}
while (currentPtr >= eltPos) {
pop();
}
clearTheListOfActiveFormattingElementsUpToTheLastMarker();
mode = IN_ROW;
return;
}
private int findLastInTableScopeTdTh() {
for (int i = currentPtr; i > 0; i--) {
@Local String name = stack[i].name;
if (stack[i].ns == "http://www.w3.org/1999/xhtml") {
if ("td" == name || "th" == name) {
return i;
} else if (name == "table" || name == "template") {
return TreeBuilder.NOT_FOUND_ON_STACK;
}
}
}
return TreeBuilder.NOT_FOUND_ON_STACK;
}
private void clearStackBackTo(int eltPos) throws SAXException {
int eltGroup = stack[eltPos].getGroup();
while (currentPtr > eltPos) { // > not >= intentional
if (stack[currentPtr].ns == "http://www.w3.org/1999/xhtml"
&& stack[currentPtr].getGroup() == TEMPLATE
&& (eltGroup == TABLE || eltGroup == TBODY_OR_THEAD_OR_TFOOT|| eltGroup == TR || eltPos == 0)) {
return;
}
pop();
}
}
private void resetTheInsertionMode() {
StackNode<T> node;
@Local String name;
@NsUri String ns;
for (int i = currentPtr; i >= 0; i--) {
node = stack[i];
name = node.name;
ns = node.ns;
if (i == 0) {
if (!(contextNamespace == "http://www.w3.org/1999/xhtml" && (contextName == "td" || contextName == "th"))) {
if (fragment) {
// Make sure we are parsing a fragment otherwise the context element doesn't make sense.
name = contextName;
ns = contextNamespace;
}
} else {
mode = framesetOk ? FRAMESET_OK : IN_BODY; // XXX from Hixie's email
return;
}
}
if ("select" == name) {
int ancestorIndex = i;
while (ancestorIndex > 0) {
StackNode<T> ancestor = stack[ancestorIndex--];
if ("http://www.w3.org/1999/xhtml" == ancestor.ns) {
if ("template" == ancestor.name) {
break;
}
if ("table" == ancestor.name) {
mode = IN_SELECT_IN_TABLE;
return;
}
}
}
mode = IN_SELECT;
return;
} else if ("td" == name || "th" == name) {
mode = IN_CELL;
return;
} else if ("tr" == name) {
mode = IN_ROW;
return;
} else if ("tbody" == name || "thead" == name || "tfoot" == name) {
mode = IN_TABLE_BODY;
return;
} else if ("caption" == name) {
mode = IN_CAPTION;
return;
} else if ("colgroup" == name) {
mode = IN_COLUMN_GROUP;
return;
} else if ("table" == name) {
mode = IN_TABLE;
return;
} else if ("http://www.w3.org/1999/xhtml" != ns) {
mode = framesetOk ? FRAMESET_OK : IN_BODY;
return;
} else if ("template" == name) {
assert templateModePtr >= 0;
mode = templateModeStack[templateModePtr];
return;
} else if ("head" == name) {
if (name == contextName) {
mode = framesetOk ? FRAMESET_OK : IN_BODY; // really
} else {
mode = IN_HEAD;
}
return;
} else if ("body" == name) {
mode = framesetOk ? FRAMESET_OK : IN_BODY;
return;
} else if ("frameset" == name) {
// TODO: Fragment case. Add error reporting.
mode = IN_FRAMESET;
return;
} else if ("html" == name) {
if (headPointer == null) {
// TODO: Fragment case. Add error reporting.
mode = BEFORE_HEAD;
} else {
mode = AFTER_HEAD;
}
return;
} else if (i == 0) {
mode = framesetOk ? FRAMESET_OK : IN_BODY;
return;
}
}
}
/**
* @throws SAXException
*
*/
private void implicitlyCloseP() throws SAXException {
int eltPos = findLastInButtonScope("p");
if (eltPos == TreeBuilder.NOT_FOUND_ON_STACK) {
return;
}
generateImpliedEndTagsExceptFor("p");
if (errorHandler != null && eltPos != currentPtr) {
errUnclosedElementsImplied(eltPos, "p");
}
while (currentPtr >= eltPos) {
pop();
}
}
private boolean debugOnlyClearLastStackSlot() {
stack[currentPtr] = null;
return true;
}
private boolean debugOnlyClearLastListSlot() {
listOfActiveFormattingElements[listPtr] = null;
return true;
}
private void pushTemplateMode(int mode) {
templateModePtr++;
if (templateModePtr == templateModeStack.length) {
int[] newStack = new int[templateModeStack.length + 64];
System.arraycopy(templateModeStack, 0, newStack, 0, templateModeStack.length);
templateModeStack = newStack;
}
templateModeStack[templateModePtr] = mode;
}
@SuppressWarnings("unchecked") private void push(StackNode<T> node) throws SAXException {
currentPtr++;
if (currentPtr == stack.length) {
StackNode<T>[] newStack = new StackNode[stack.length + 64];
System.arraycopy(stack, 0, newStack, 0, stack.length);
stack = newStack;
}
stack[currentPtr] = node;
elementPushed(node.ns, node.popName, node.node);
}
@SuppressWarnings("unchecked") private void silentPush(StackNode<T> node) throws SAXException {
currentPtr++;
if (currentPtr == stack.length) {
StackNode<T>[] newStack = new StackNode[stack.length + 64];
System.arraycopy(stack, 0, newStack, 0, stack.length);
stack = newStack;
}
stack[currentPtr] = node;
}
@SuppressWarnings("unchecked") private void append(StackNode<T> node) {
listPtr++;
if (listPtr == listOfActiveFormattingElements.length) {
StackNode<T>[] newList = new StackNode[listOfActiveFormattingElements.length + 64];
System.arraycopy(listOfActiveFormattingElements, 0, newList, 0,
listOfActiveFormattingElements.length);
listOfActiveFormattingElements = newList;
}
listOfActiveFormattingElements[listPtr] = node;
}
@Inline private void insertMarker() {
append(null);
}
private void clearTheListOfActiveFormattingElementsUpToTheLastMarker() {
while (listPtr > -1) {
if (listOfActiveFormattingElements[listPtr] == null) {
--listPtr;
return;
}
listOfActiveFormattingElements[listPtr].release(this);
--listPtr;
}
}
@Inline private boolean isCurrent(@Local String name) {
return stack[currentPtr].ns == "http://www.w3.org/1999/xhtml" &&
name == stack[currentPtr].name;
}
private void removeFromStack(int pos) throws SAXException {
if (currentPtr == pos) {
pop();
} else {
fatal();
stack[pos].release(this);
System.arraycopy(stack, pos + 1, stack, pos, currentPtr - pos);
assert debugOnlyClearLastStackSlot();
currentPtr--;
}
}
private void removeFromStack(StackNode<T> node) throws SAXException {
if (stack[currentPtr] == node) {
pop();
} else {
int pos = currentPtr - 1;
while (pos >= 0 && stack[pos] != node) {
pos--;
}
if (pos == -1) {
// dead code?
return;
}
fatal();
node.release(this);
System.arraycopy(stack, pos + 1, stack, pos, currentPtr - pos);
currentPtr--;
}
}
private void removeFromListOfActiveFormattingElements(int pos) {
assert listOfActiveFormattingElements[pos] != null;
listOfActiveFormattingElements[pos].release(this);
if (pos == listPtr) {
assert debugOnlyClearLastListSlot();
listPtr--;
return;
}
assert pos < listPtr;
System.arraycopy(listOfActiveFormattingElements, pos + 1,
listOfActiveFormattingElements, pos, listPtr - pos);
assert debugOnlyClearLastListSlot();
listPtr--;
}
/**
* Adoption agency algorithm.
*
* @param name subject as described in the specified algorithm.
* @return Returns true if the algorithm has completed and there is nothing remaining to
* be done. Returns false if the algorithm needs to "act as described in the 'any other
* end tag' entry" as described in the specified algorithm.
* @throws SAXException
*/
private boolean adoptionAgencyEndTag(@Local String name) throws SAXException {
// This check intends to ensure that for properly nested tags, closing tags will match
// against the stack instead of the listOfActiveFormattingElements.
if (stack[currentPtr].ns == "http://www.w3.org/1999/xhtml" &&
stack[currentPtr].name == name &&
findInListOfActiveFormattingElements(stack[currentPtr]) == -1) {
// If the current element matches the name but isn't on the list of active
// formatting elements, then it is possible that the list was mangled by the Noah's Ark
// clause. In this case, we want to match the end tag against the stack instead of
// proceeding with the AAA algorithm that may match against the list of
// active formatting elements (and possibly mangle the tree in unexpected ways).
pop();
return true;
}
// If you crash around here, perhaps some stack node variable claimed to
// be a weak ref isn't.
for (int i = 0; i < 8; ++i) {
int formattingEltListPos = listPtr;
while (formattingEltListPos > -1) {
StackNode<T> listNode = listOfActiveFormattingElements[formattingEltListPos]; // weak ref
if (listNode == null) {
formattingEltListPos = -1;
break;
} else if (listNode.name == name) {
break;
}
formattingEltListPos--;
}
if (formattingEltListPos == -1) {
return false;
}
// this *looks* like a weak ref to the list of formatting elements
StackNode<T> formattingElt = listOfActiveFormattingElements[formattingEltListPos];
int formattingEltStackPos = currentPtr;
boolean inScope = true;
while (formattingEltStackPos > -1) {
StackNode<T> node = stack[formattingEltStackPos]; // weak ref
if (node == formattingElt) {
break;
} else if (node.isScoping()) {
inScope = false;
}
formattingEltStackPos--;
}
if (formattingEltStackPos == -1) {
errNoElementToCloseButEndTagSeen(name);
removeFromListOfActiveFormattingElements(formattingEltListPos);
return true;
}
if (!inScope) {
errNoElementToCloseButEndTagSeen(name);
return true;
}
// stackPos now points to the formatting element and it is in scope
if (formattingEltStackPos != currentPtr) {
errEndTagViolatesNestingRules(name);
}
int furthestBlockPos = formattingEltStackPos + 1;
while (furthestBlockPos <= currentPtr) {
StackNode<T> node = stack[furthestBlockPos]; // weak ref
assert furthestBlockPos > 0: "How is formattingEltStackPos + 1 not > 0?";
if (node.isSpecial()) {
break;
}
furthestBlockPos++;
}
if (furthestBlockPos > currentPtr) {
// no furthest block
while (currentPtr >= formattingEltStackPos) {
pop();
}
removeFromListOfActiveFormattingElements(formattingEltListPos);
return true;
}
// commonAncestor is used for running the algorithm and
// insertionCommonAncestor is used for the actual insertions to
// keep them depth-limited.
StackNode<T> commonAncestor = stack[formattingEltStackPos - 1]; // weak ref
T insertionCommonAncestor = nodeFromStackWithBlinkCompat(formattingEltStackPos - 1); // weak ref
StackNode<T> furthestBlock = stack[furthestBlockPos]; // weak ref
// detachFromParent(furthestBlock.node); XXX AAA CHANGE
int bookmark = formattingEltListPos;
int nodePos = furthestBlockPos;
StackNode<T> lastNode = furthestBlock; // weak ref
int j = 0;
for (;;) {
++j;
nodePos--;
if (nodePos == formattingEltStackPos) {
break;
}
StackNode<T> node = stack[nodePos]; // weak ref
int nodeListPos = findInListOfActiveFormattingElements(node);
if (j > 3 && nodeListPos != -1) {
removeFromListOfActiveFormattingElements(nodeListPos);
// Adjust the indices into the list to account
// for the removal of nodeListPos.
if (nodeListPos <= formattingEltListPos) {
formattingEltListPos--;
}
if (nodeListPos <= bookmark) {
bookmark--;
}
// Update position to reflect removal from list.
nodeListPos = -1;
}
if (nodeListPos == -1) {
assert formattingEltStackPos < nodePos;
assert bookmark < nodePos;
assert furthestBlockPos > nodePos;
removeFromStack(nodePos); // node is now a bad pointer in C++
furthestBlockPos--;
continue;
}
// now node is both on stack and in the list
if (nodePos == furthestBlockPos) {
bookmark = nodeListPos + 1;
}
// if (hasChildren(node.node)) { XXX AAA CHANGE
assert node == listOfActiveFormattingElements[nodeListPos];
assert node == stack[nodePos];
T clone = createElement("http://www.w3.org/1999/xhtml",
node.name, node.attributes.cloneAttributes(), insertionCommonAncestor
// CPPONLY: , htmlCreator(node.getHtmlCreator())
);
StackNode<T> newNode = createStackNode(node.getFlags(), node.ns,
node.name, clone, node.popName, node.attributes
// CPPONLY: , node.getHtmlCreator()
// [NOCPP[
, node.getLocator()
// ]NOCPP]
); // creation ownership goes to stack
node.dropAttributes(); // adopt ownership to newNode
stack[nodePos] = newNode;
newNode.retain(); // retain for list
listOfActiveFormattingElements[nodeListPos] = newNode;
node.release(this); // release from stack
node.release(this); // release from list
node = newNode;
// } XXX AAA CHANGE
detachFromParent(lastNode.node);
appendElement(lastNode.node, nodeFromStackWithBlinkCompat(nodePos));
lastNode = node;
}
// If we insert into a foster parent, for simplicity, we insert
// accoding to the spec without Blink's depth limit.
if (commonAncestor.isFosterParenting()) {
fatal();
detachFromParent(lastNode.node);
insertIntoFosterParent(lastNode.node);
} else {
detachFromParent(lastNode.node);
appendElement(lastNode.node, insertionCommonAncestor);
}
T clone = createElement("http://www.w3.org/1999/xhtml",
formattingElt.name,
formattingElt.attributes.cloneAttributes(), furthestBlock.node
// CPPONLY: , htmlCreator(formattingElt.getHtmlCreator())
);
StackNode<T> formattingClone = createStackNode(
formattingElt.getFlags(), formattingElt.ns,
formattingElt.name, clone, formattingElt.popName,
formattingElt.attributes
// CPPONLY: , formattingElt.getHtmlCreator()
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
); // Ownership transfers to stack below
formattingElt.dropAttributes(); // transfer ownership to
// formattingClone
appendChildrenToNewParent(furthestBlock.node, clone);
appendElement(clone, furthestBlock.node);
removeFromListOfActiveFormattingElements(formattingEltListPos);
insertIntoListOfActiveFormattingElements(formattingClone, bookmark);
assert formattingEltStackPos < furthestBlockPos;
removeFromStack(formattingEltStackPos);
// furthestBlockPos is now off by one and points to the slot after
// it
insertIntoStack(formattingClone, furthestBlockPos);
}
return true;
}
private void insertIntoStack(StackNode<T> node, int position)
throws SAXException {
assert currentPtr + 1 < stack.length;
assert position <= currentPtr + 1;
if (position == currentPtr + 1) {
push(node);
} else {
System.arraycopy(stack, position, stack, position + 1,
(currentPtr - position) + 1);
currentPtr++;
stack[position] = node;
}
}
private void insertIntoListOfActiveFormattingElements(
StackNode<T> formattingClone, int bookmark) {
formattingClone.retain();
assert listPtr + 1 < listOfActiveFormattingElements.length;
if (bookmark <= listPtr) {
System.arraycopy(listOfActiveFormattingElements, bookmark,
listOfActiveFormattingElements, bookmark + 1,
(listPtr - bookmark) + 1);
}
listPtr++;
listOfActiveFormattingElements[bookmark] = formattingClone;
}
private int findInListOfActiveFormattingElements(StackNode<T> node) {
for (int i = listPtr; i >= 0; i--) {
if (node == listOfActiveFormattingElements[i]) {
return i;
}
}
return -1;
}
private int findInListOfActiveFormattingElementsContainsBetweenEndAndLastMarker(
@Local String name) {
for (int i = listPtr; i >= 0; i--) {
StackNode<T> node = listOfActiveFormattingElements[i];
if (node == null) {
return -1;
} else if (node.name == name) {
return i;
}
}
return -1;
}
private void maybeForgetEarlierDuplicateFormattingElement(
@Local String name, HtmlAttributes attributes) throws SAXException {
int candidate = -1;
int count = 0;
for (int i = listPtr; i >= 0; i--) {
StackNode<T> node = listOfActiveFormattingElements[i];
if (node == null) {
break;
}
if (node.name == name && node.attributes.equalsAnother(attributes)) {
candidate = i;
++count;
}
}
if (count >= 3) {
removeFromListOfActiveFormattingElements(candidate);
}
}
private int findLastOrRoot(@Local String name) {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml" && stack[i].name == name) {
return i;
}
}
return 0;
}
private int findLastOrRoot(int group) {
for (int i = currentPtr; i > 0; i--) {
if (stack[i].ns == "http://www.w3.org/1999/xhtml" && stack[i].getGroup() == group) {
return i;
}
}
return 0;
}
/**
* Attempt to add attribute to the body element.
* @param attributes the attributes
* @return <code>true</code> iff the attributes were added
* @throws SAXException
*/
private boolean addAttributesToBody(HtmlAttributes attributes)
throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
if (currentPtr >= 1) {
StackNode<T> body = stack[1];
if (body.getGroup() == TreeBuilder.BODY) {
addAttributesToElement(body.node, attributes);
return true;
}
}
return false;
}
private void addAttributesToHtml(HtmlAttributes attributes)
throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
addAttributesToElement(stack[0].node, attributes);
}
private void pushHeadPointerOntoStack() throws SAXException {
assert headPointer != null;
assert mode == AFTER_HEAD;
fatal();
silentPush(createStackNode(ElementName.HEAD, headPointer
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
));
}
/**
* @throws SAXException
*
*/
private void reconstructTheActiveFormattingElements() throws SAXException {
if (listPtr == -1) {
return;
}
StackNode<T> mostRecent = listOfActiveFormattingElements[listPtr];
if (mostRecent == null || isInStack(mostRecent)) {
return;
}
int entryPos = listPtr;
for (;;) {
entryPos--;
if (entryPos == -1) {
break;
}
if (listOfActiveFormattingElements[entryPos] == null) {
break;
}
if (isInStack(listOfActiveFormattingElements[entryPos])) {
break;
}
}
while (entryPos < listPtr) {
entryPos++;
StackNode<T> entry = listOfActiveFormattingElements[entryPos];
StackNode<T> current = stack[currentPtr];
T clone;
if (current.isFosterParenting()) {
clone = createAndInsertFosterParentedElement("http://www.w3.org/1999/xhtml", entry.name,
entry.attributes.cloneAttributes()
// CPPONLY: , htmlCreator(entry.getHtmlCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
clone = createElement("http://www.w3.org/1999/xhtml", entry.name,
entry.attributes.cloneAttributes(), currentNode
// CPPONLY: , htmlCreator(entry.getHtmlCreator())
);
appendElement(clone, currentNode);
}
StackNode<T> entryClone = createStackNode(entry.getFlags(),
entry.ns, entry.name, clone, entry.popName,
entry.attributes
// CPPONLY: , entry.getHtmlCreator()
// [NOCPP[
, entry.getLocator()
// ]NOCPP]
);
entry.dropAttributes(); // transfer ownership to entryClone
push(entryClone);
// stack takes ownership of the local variable
listOfActiveFormattingElements[entryPos] = entryClone;
// overwriting the old entry on the list, so release & retain
entry.release(this);
entryClone.retain();
}
}
void notifyUnusedStackNode(int idxInStackNodes) {
// stackNodesIdx is the earliest possible index of a stack node that might be unused,
// so update the index if necessary.
if (idxInStackNodes < stackNodesIdx) {
stackNodesIdx = idxInStackNodes;
}
}
@SuppressWarnings("unchecked") private StackNode<T> getUnusedStackNode() {
// Search for an unused stack node.
while (stackNodesIdx < numStackNodes) {
if (stackNodes[stackNodesIdx].isUnused()) {
return stackNodes[stackNodesIdx++];
}
stackNodesIdx++;
}
if (stackNodesIdx < stackNodes.length) {
// No unused stack nodes, but there is still space in the storage array.
stackNodes[stackNodesIdx] = new StackNode<T>(stackNodesIdx);
numStackNodes++;
return stackNodes[stackNodesIdx++];
}
// Could not find an unused stack node and storage array is full.
StackNode<T>[] newStack = new StackNode[stackNodes.length + 64];
System.arraycopy(stackNodes, 0, newStack, 0, stackNodes.length);
stackNodes = newStack;
// Create a new stack node and return it.
stackNodes[stackNodesIdx] = new StackNode<T>(stackNodesIdx);
numStackNodes++;
return stackNodes[stackNodesIdx++];
}
private StackNode<T> createStackNode(int flags, @NsUri String ns, @Local String name, T node,
@Local String popName, HtmlAttributes attributes
// CPPONLY: , @HtmlCreator Object htmlCreator
// [NOCPP[
, TaintableLocatorImpl locator
// ]NOCPP]
) {
StackNode<T> instance = getUnusedStackNode();
instance.setValues(flags, ns, name, node, popName, attributes
// CPPONLY: , htmlCreator
// [NOCPP[
, locator
// ]NOCPP]
);
return instance;
}
private StackNode<T> createStackNode(ElementName elementName, T node
// [NOCPP[
, TaintableLocatorImpl locator
// ]NOCPP]
) {
StackNode<T> instance = getUnusedStackNode();
instance.setValues(elementName, node
// [NOCPP[
, locator
// ]NOCPP]
);
return instance;
}
private StackNode<T> createStackNode(ElementName elementName, T node, HtmlAttributes attributes
// [NOCPP[
, TaintableLocatorImpl locator
// ]NOCPP]
) {
StackNode<T> instance = getUnusedStackNode();
instance.setValues(elementName, node, attributes
// [NOCPP[
, locator
// ]NOCPP]
);
return instance;
}
private StackNode<T> createStackNode(ElementName elementName, T node, @Local String popName
// [NOCPP[
, TaintableLocatorImpl locator
// ]NOCPP]
) {
StackNode<T> instance = getUnusedStackNode();
instance.setValues(elementName, node, popName
// [NOCPP[
, locator
// ]NOCPP]
);
return instance;
}
private StackNode<T> createStackNode(ElementName elementName, @Local String popName, T node
// [NOCPP[
, TaintableLocatorImpl locator
// ]NOCPP]
) {
StackNode<T> instance = getUnusedStackNode();
instance.setValues(elementName, popName, node
// [NOCPP[
, locator
// ]NOCPP]
);
return instance;
}
private StackNode<T> createStackNode(ElementName elementName, T node, @Local String popName,
boolean markAsIntegrationPoint
// [NOCPP[
, TaintableLocatorImpl locator
// ]NOCPP]
) {
StackNode<T> instance = getUnusedStackNode();
instance.setValues(elementName, node, popName, markAsIntegrationPoint
// [NOCPP[
, locator
// ]NOCPP]
);
return instance;
}
private void insertIntoFosterParent(T child) throws SAXException {
int tablePos = findLastOrRoot(TreeBuilder.TABLE);
int templatePos = findLastOrRoot(TreeBuilder.TEMPLATE);
if (templatePos >= tablePos) {
appendElement(child, stack[templatePos].node);
return;
}
StackNode<T> node = stack[tablePos];
insertFosterParentedChild(child, node.node, stack[tablePos - 1].node);
}
private T createAndInsertFosterParentedElement(@NsUri String ns, @Local String name,
HtmlAttributes attributes
// CPPONLY: , @Creator Object creator
) throws SAXException {
return createAndInsertFosterParentedElement(ns, name, attributes, null
// CPPONLY: , creator
);
}
private T createAndInsertFosterParentedElement(@NsUri String ns, @Local String name,
HtmlAttributes attributes, T form
// CPPONLY: , @Creator Object creator
) throws SAXException {
int tablePos = findLastOrRoot(TreeBuilder.TABLE);
int templatePos = findLastOrRoot(TreeBuilder.TEMPLATE);
if (templatePos >= tablePos) {
T child = createElement(ns, name, attributes, form, stack[templatePos].node
// CPPONLY: , creator
);
appendElement(child, stack[templatePos].node);
return child;
}
StackNode<T> node = stack[tablePos];
return createAndInsertFosterParentedElement(ns, name, attributes, form, node.node, stack[tablePos - 1].node
// CPPONLY: , creator
);
}
private boolean isInStack(StackNode<T> node) {
for (int i = currentPtr; i >= 0; i--) {
if (stack[i] == node) {
return true;
}
}
return false;
}
private void popTemplateMode() {
templateModePtr--;
}
private void pop() throws SAXException {
StackNode<T> node = stack[currentPtr];
assert debugOnlyClearLastStackSlot();
currentPtr--;
elementPopped(node.ns, node.popName, node.node);
node.release(this);
}
private void popForeign(int origPos, int eltPos) throws SAXException {
StackNode<T> node = stack[currentPtr];
if (origPos != currentPtr || eltPos != currentPtr) {
markMalformedIfScript(node.node);
}
assert debugOnlyClearLastStackSlot();
currentPtr--;
elementPopped(node.ns, node.popName, node.node);
node.release(this);
}
private void silentPop() throws SAXException {
StackNode<T> node = stack[currentPtr];
assert debugOnlyClearLastStackSlot();
currentPtr--;
node.release(this);
}
private void popOnEof() throws SAXException {
StackNode<T> node = stack[currentPtr];
assert debugOnlyClearLastStackSlot();
currentPtr--;
markMalformedIfScript(node.node);
elementPopped(node.ns, node.popName, node.node);
node.release(this);
}
// [NOCPP[
private void checkAttributes(HtmlAttributes attributes, @NsUri String ns)
throws SAXException {
if (errorHandler != null) {
int len = attributes.getXmlnsLength();
for (int i = 0; i < len; i++) {
AttributeName name = attributes.getXmlnsAttributeName(i);
if (name == AttributeName.XMLNS) {
String xmlns = attributes.getXmlnsValue(i);
if (!ns.equals(xmlns)) {
err("Bad value \u201C"
+ xmlns
+ "\u201D for the attribute \u201Cxmlns\u201D (only \u201C"
+ ns + "\u201D permitted here).");
switch (namePolicy) {
case ALTER_INFOSET:
// fall through
case ALLOW:
warn("Attribute \u201Cxmlns\u201D is not serializable as XML 1.0.");
break;
case FATAL:
fatal("Attribute \u201Cxmlns\u201D is not serializable as XML 1.0.");
break;
}
}
} else if (ns != "http://www.w3.org/1999/xhtml"
&& name == AttributeName.XMLNS_XLINK) {
String xmlns = attributes.getXmlnsValue(i);
if (!"http://www.w3.org/1999/xlink".equals(xmlns)) {
err("Bad value \u201C"
+ xmlns
+ "\u201D for the attribute \u201Cxmlns:link\u201D (only \u201Chttp://www.w3.org/1999/xlink\u201D permitted here).");
switch (namePolicy) {
case ALTER_INFOSET:
// fall through
case ALLOW:
warn("Attribute \u201Cxmlns:xlink\u201D with a value other than \u201Chttp://www.w3.org/1999/xlink\u201D is not serializable as XML 1.0 without changing document semantics.");
break;
case FATAL:
fatal("Attribute \u201Cxmlns:xlink\u201D with a value other than \u201Chttp://www.w3.org/1999/xlink\u201D is not serializable as XML 1.0 without changing document semantics.");
break;
}
}
} else {
err("Attribute \u201C" + attributes.getXmlnsLocalName(i)
+ "\u201D not allowed here.");
switch (namePolicy) {
case ALTER_INFOSET:
// fall through
case ALLOW:
warn("Attribute with the local name \u201C"
+ attributes.getXmlnsLocalName(i)
+ "\u201D is not serializable as XML 1.0.");
break;
case FATAL:
fatal("Attribute with the local name \u201C"
+ attributes.getXmlnsLocalName(i)
+ "\u201D is not serializable as XML 1.0.");
break;
}
}
}
}
attributes.processNonNcNames(this, namePolicy);
}
private String checkPopName(@Local String name) throws SAXException {
if (NCName.isNCName(name)) {
return name;
} else {
switch (namePolicy) {
case ALLOW:
warn("Element name \u201C" + name
+ "\u201D cannot be represented as XML 1.0.");
return name;
case ALTER_INFOSET:
warn("Element name \u201C" + name
+ "\u201D cannot be represented as XML 1.0.");
return NCName.escapeName(name);
case FATAL:
fatal("Element name \u201C" + name
+ "\u201D cannot be represented as XML 1.0.");
}
}
return null; // keep compiler happy
}
// ]NOCPP]
private void appendHtmlElementToDocumentAndPush(HtmlAttributes attributes)
throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
T elt = createHtmlElementSetAsRoot(attributes);
StackNode<T> node = createStackNode(ElementName.HTML,
elt
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
private void appendHtmlElementToDocumentAndPush() throws SAXException {
appendHtmlElementToDocumentAndPush(tokenizer.emptyAttributes());
}
private void appendToCurrentNodeAndPushHeadElement(HtmlAttributes attributes)
throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
T elt = createElement("http://www.w3.org/1999/xhtml", "head", attributes, currentNode
/*
* head uses NS_NewHTMLSharedElement creator
*/
// CPPONLY: , htmlCreator(NS_NewHTMLSharedElement)
);
appendElement(elt, currentNode);
headPointer = elt;
StackNode<T> node = createStackNode(ElementName.HEAD,
elt
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
private void appendToCurrentNodeAndPushBodyElement(HtmlAttributes attributes)
throws SAXException {
appendToCurrentNodeAndPushElement(ElementName.BODY,
attributes);
}
private void appendToCurrentNodeAndPushBodyElement() throws SAXException {
appendToCurrentNodeAndPushBodyElement(tokenizer.emptyAttributes());
}
private void appendToCurrentNodeAndPushFormElementMayFoster(
HtmlAttributes attributes) throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1999/xhtml", "form", attributes
// CPPONLY: , htmlCreator(NS_NewHTMLFormElement)
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1999/xhtml", "form", attributes, currentNode
// CPPONLY: , htmlCreator(NS_NewHTMLFormElement)
);
appendElement(elt, currentNode);
}
if (!isTemplateContents()) {
formPointer = elt;
}
StackNode<T> node = createStackNode(ElementName.FORM,
elt
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
private void appendToCurrentNodeAndPushFormattingElementMayFoster(
ElementName elementName, HtmlAttributes attributes)
throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
// This method can't be called for custom elements
HtmlAttributes clone = attributes.cloneAttributes();
// Attributes must not be read after calling createElement, because
// createElement may delete attributes in C++.
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1999/xhtml", elementName.getName(), attributes
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1999/xhtml", elementName.getName(), attributes, currentNode
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
appendElement(elt, currentNode);
}
StackNode<T> node = createStackNode(elementName, elt, clone
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
append(node);
node.retain(); // append doesn't retain itself
}
private void appendToCurrentNodeAndPushElement(ElementName elementName,
HtmlAttributes attributes)
throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
// This method can't be called for custom elements
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
T elt = createElement("http://www.w3.org/1999/xhtml", elementName.getName(), attributes, currentNode
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
if (ElementName.TEMPLATE == elementName) {
T root = getDeclarativeShadowRoot(currentNode, elt, attributes);
if (root != null) {
setDocumentFragmentForTemplate(elt, root);
elt = root;
} else {
appendElement(elt, currentNode);
elt = getDocumentFragmentForTemplate(elt);
}
} else {
appendElement(elt, currentNode);
}
StackNode<T> node = createStackNode(elementName, elt
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
private void appendToCurrentNodeAndPushElementMayFoster(ElementName elementName,
HtmlAttributes attributes)
throws SAXException {
@Local String popName = elementName.getName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
if (!elementName.isInterned()) {
popName = checkPopName(popName);
}
// ]NOCPP]
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1999/xhtml", popName, attributes
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1999/xhtml", popName, attributes, currentNode
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
appendElement(elt, currentNode);
}
StackNode<T> node = createStackNode(elementName, elt, popName
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
private void appendToCurrentNodeAndPushElementMayFosterMathML(
ElementName elementName, HtmlAttributes attributes)
throws SAXException {
@Local String popName = elementName.getName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1998/Math/MathML");
if (!elementName.isInterned()) {
popName = checkPopName(popName);
}
// ]NOCPP]
boolean markAsHtmlIntegrationPoint = false;
if (ElementName.ANNOTATION_XML == elementName
&& annotationXmlEncodingPermitsHtml(attributes)) {
markAsHtmlIntegrationPoint = true;
}
// Attributes must not be read after calling createElement(), since
// createElement may delete the object in C++.
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1998/Math/MathML", popName, attributes
// CPPONLY: , htmlCreator(null)
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1998/Math/MathML", popName, attributes, currentNode
// CPPONLY: , htmlCreator(null)
);
appendElement(elt, currentNode);
}
StackNode<T> node = createStackNode(elementName, elt, popName,
markAsHtmlIntegrationPoint
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
// [NOCPP[
T getDocumentFragmentForTemplate(T template) {
return template;
}
void setDocumentFragmentForTemplate(T template, T fragment) {
}
T getShadowRootFromHost(T host, T template, String shadowRootMode,
boolean shadowRootIsClonable, boolean shadowRootDelegatesFocus) {
return null;
}
T getFormPointerForContext(T context) {
return null;
}
// ]NOCPP]
private boolean annotationXmlEncodingPermitsHtml(HtmlAttributes attributes) {
String encoding = attributes.getValue(AttributeName.ENCODING);
if (encoding == null) {
return false;
}
return Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"application/xhtml+xml", encoding)
|| Portability.lowerCaseLiteralEqualsIgnoreAsciiCaseString(
"text/html", encoding);
}
private void appendToCurrentNodeAndPushElementMayFosterSVG(
ElementName elementName, HtmlAttributes attributes)
throws SAXException {
@Local String popName = elementName.getCamelCaseName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/2000/svg");
if (!elementName.isInterned()) {
popName = checkPopName(popName);
}
// ]NOCPP]
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/2000/svg", popName, attributes
// CPPONLY: , svgCreator(elementName.getSvgCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/2000/svg", popName, attributes, currentNode
// CPPONLY: , svgCreator(elementName.getSvgCreator())
);
appendElement(elt, currentNode);
}
StackNode<T> node = createStackNode(elementName, popName, elt
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
private void appendToCurrentNodeAndPushElementMayFoster(ElementName elementName,
HtmlAttributes attributes, T form)
throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
// Can't be called for custom elements
T elt;
T formOwner = form == null || fragment || isTemplateContents() ? null : form;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1999/xhtml", elementName.getName(),
attributes, formOwner
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1999/xhtml", elementName.getName(),
attributes, formOwner, currentNode
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
appendElement(elt, currentNode);
}
StackNode<T> node = createStackNode(elementName, elt
// [NOCPP[
, errorHandler == null ? null : new TaintableLocatorImpl(tokenizer)
// ]NOCPP]
);
push(node);
}
private void appendVoidElementToCurrent(
ElementName elementName, HtmlAttributes attributes)
throws SAXException {
@Local String popName = elementName.getName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
if (!elementName.isInterned()) {
popName = checkPopName(popName);
}
// ]NOCPP]
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
T elt = createElement("http://www.w3.org/1999/xhtml", popName, attributes, currentNode
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
appendElement(elt, currentNode);
elementPushed("http://www.w3.org/1999/xhtml", popName, elt);
elementPopped("http://www.w3.org/1999/xhtml", popName, elt);
}
private void appendVoidElementToCurrentMayFoster(
ElementName elementName, HtmlAttributes attributes, T form) throws SAXException {
@Local String name = elementName.getName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
// Can't be called for custom elements
T elt;
T formOwner = form == null || fragment || isTemplateContents() ? null : form;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1999/xhtml", name,
attributes, formOwner
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1999/xhtml", name,
attributes, formOwner, currentNode
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
appendElement(elt, currentNode);
}
elementPushed("http://www.w3.org/1999/xhtml", name, elt);
elementPopped("http://www.w3.org/1999/xhtml", name, elt);
}
private void appendVoidElementToCurrentMayFoster(
ElementName elementName, HtmlAttributes attributes)
throws SAXException {
@Local String popName = elementName.getName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
if (!elementName.isInterned()) {
popName = checkPopName(popName);
}
// ]NOCPP]
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1999/xhtml", popName, attributes
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1999/xhtml", popName, attributes, currentNode
// CPPONLY: , htmlCreator(elementName.getHtmlCreator())
);
appendElement(elt, currentNode);
}
elementPushed("http://www.w3.org/1999/xhtml", popName, elt);
elementPopped("http://www.w3.org/1999/xhtml", popName, elt);
}
private void appendVoidElementToCurrentMayFosterSVG(
ElementName elementName, HtmlAttributes attributes)
throws SAXException {
@Local String popName = elementName.getCamelCaseName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/2000/svg");
if (!elementName.isInterned()) {
popName = checkPopName(popName);
}
// ]NOCPP]
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/2000/svg", popName, attributes
// CPPONLY: , svgCreator(elementName.getSvgCreator())
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/2000/svg", popName, attributes, currentNode
// CPPONLY: , svgCreator(elementName.getSvgCreator())
);
appendElement(elt, currentNode);
}
elementPushed("http://www.w3.org/2000/svg", popName, elt);
elementPopped("http://www.w3.org/2000/svg", popName, elt);
}
private void appendVoidElementToCurrentMayFosterMathML(
ElementName elementName, HtmlAttributes attributes)
throws SAXException {
@Local String popName = elementName.getName();
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1998/Math/MathML");
if (!elementName.isInterned()) {
popName = checkPopName(popName);
}
// ]NOCPP]
T elt;
StackNode<T> current = stack[currentPtr];
if (current.isFosterParenting()) {
fatal();
elt = createAndInsertFosterParentedElement("http://www.w3.org/1998/Math/MathML", popName, attributes
// CPPONLY: , htmlCreator(null)
);
} else {
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
elt = createElement("http://www.w3.org/1998/Math/MathML", popName, attributes, currentNode
// CPPONLY: , htmlCreator(null)
);
appendElement(elt, currentNode);
}
elementPushed("http://www.w3.org/1998/Math/MathML", popName, elt);
elementPopped("http://www.w3.org/1998/Math/MathML", popName, elt);
}
private void appendVoidInputToCurrent(HtmlAttributes attributes, T form) throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
// Can't be called for custom elements
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
T elt = createElement("http://www.w3.org/1999/xhtml", "input", attributes,
form == null || fragment || isTemplateContents() ? null : form, currentNode
// CPPONLY: , htmlCreator(NS_NewHTMLInputElement)
);
appendElement(elt, currentNode);
elementPushed("http://www.w3.org/1999/xhtml", "input", elt);
elementPopped("http://www.w3.org/1999/xhtml", "input", elt);
}
private void appendVoidFormToCurrent(HtmlAttributes attributes) throws SAXException {
// [NOCPP[
checkAttributes(attributes, "http://www.w3.org/1999/xhtml");
// ]NOCPP]
T currentNode = nodeFromStackWithBlinkCompat(currentPtr);
T elt = createElement("http://www.w3.org/1999/xhtml", "form",
attributes, currentNode
// CPPONLY: , htmlCreator(NS_NewHTMLFormElement)
);
formPointer = elt;
// ownership transferred to form pointer
appendElement(elt, currentNode);
elementPushed("http://www.w3.org/1999/xhtml", "form", elt);
elementPopped("http://www.w3.org/1999/xhtml", "form", elt);
}
// [NOCPP[
private final void accumulateCharactersForced(@Const @NoLength char[] buf,
int start, int length) throws SAXException {
System.arraycopy(buf, start, charBuffer, charBufferLen, length);
charBufferLen += length;
}
@Override public void ensureBufferSpace(int inputLength)
throws SAXException {
// TODO: Unify Tokenizer.strBuf and TreeBuilder.charBuffer so that
// this method becomes unnecessary.
int worstCase = charBufferLen + inputLength;
if (charBuffer == null) {
// Add an arbitrary small value to avoid immediate reallocation
// once there are a few characters in the buffer.
charBuffer = new char[worstCase + 128];
} else if (worstCase > charBuffer.length) {
// HotSpot reportedly allocates memory with 8-byte accuracy, so
// there's no point in trying to do math here to avoid slop.
// Maybe we should add some small constant to worstCase here
// but not doing that without profiling. In C++ with jemalloc,
// the corresponding method should do math to round up here
// to avoid slop.
char[] newBuf = new char[worstCase];
System.arraycopy(charBuffer, 0, newBuf, 0, charBufferLen);
charBuffer = newBuf;
}
}
// ]NOCPP]
protected void accumulateCharacters(@Const @NoLength char[] buf, int start,
int length) throws SAXException {
appendCharacters(stack[currentPtr].node, buf, start, length);
}
// ------------------------------- //
protected final void requestSuspension() {
tokenizer.requestSuspension();
}
protected abstract T createElement(@NsUri String ns, @Local String name,
HtmlAttributes attributes, T intendedParent
// CPPONLY: , @Creator Object creator
) throws SAXException;
protected T createElement(@NsUri String ns, @Local String name,
HtmlAttributes attributes, T form, T intendedParent
// CPPONLY: , @Creator Object creator
) throws SAXException {
return createElement("http://www.w3.org/1999/xhtml", name, attributes, intendedParent
// CPPONLY: , creator
);
}
protected abstract T createHtmlElementSetAsRoot(HtmlAttributes attributes)
throws SAXException;
protected abstract void detachFromParent(T element) throws SAXException;
protected abstract boolean hasChildren(T element) throws SAXException;
protected abstract void appendElement(T child, T newParent)
throws SAXException;
protected abstract void appendChildrenToNewParent(T oldParent, T newParent)
throws SAXException;
protected abstract void insertFosterParentedChild(T child, T table,
T stackParent) throws SAXException;
// We don't generate CPP code for this method because it is not used in generated CPP
// code. Instead, the form owner version of this method is called with a null form owner.
// [NOCPP[
protected abstract T createAndInsertFosterParentedElement(@NsUri String ns, @Local String name,
HtmlAttributes attributes, T table, T stackParent) throws SAXException;
// ]NOCPP]
protected T createAndInsertFosterParentedElement(@NsUri String ns, @Local String name,
HtmlAttributes attributes, T form, T table, T stackParent
// CPPONLY: , @Creator Object creator
) throws SAXException {
return createAndInsertFosterParentedElement(ns, name, attributes, table, stackParent);
};
protected abstract void insertFosterParentedCharacters(
@NoLength char[] buf, int start, int length, T table, T stackParent)
throws SAXException;
protected abstract void appendCharacters(T parent, @NoLength char[] buf,
int start, int length) throws SAXException;
protected abstract void appendComment(T parent, @NoLength char[] buf,
int start, int length) throws SAXException;
protected abstract void appendCommentToDocument(@NoLength char[] buf,
int start, int length) throws SAXException;
protected abstract void addAttributesToElement(T element,
HtmlAttributes attributes) throws SAXException;
protected void markMalformedIfScript(T elt) throws SAXException {
}
protected void start(boolean fragmentMode) throws SAXException {
}
protected void end() throws SAXException {
}
protected void appendDoctypeToDocument(@Local String name,
String publicIdentifier, String systemIdentifier)
throws SAXException {
}
protected void elementPushed(@NsUri String ns, @Local String name, T node)
throws SAXException {
}
protected void elementPopped(@NsUri String ns, @Local String name, T node)
throws SAXException {
}
// [NOCPP[
protected void documentMode(DocumentMode m, String publicIdentifier,
String systemIdentifier)
throws SAXException {
}
/**
* @see nu.validator.htmlparser.common.TokenHandler#wantsComments()
*/
public boolean wantsComments() {
return wantingComments;
}
public void setIgnoringComments(boolean ignoreComments) {
wantingComments = !ignoreComments;
}
/**
* Sets the errorHandler.
*
* @param errorHandler
* the errorHandler to set
*/
public final void setErrorHandler(ErrorHandler errorHandler) {
this.errorHandler = errorHandler;
}
/**
* Returns the errorHandler.
*
* @return the errorHandler
*/
public ErrorHandler getErrorHandler() {
return errorHandler;
}
/**
* The argument MUST be an interned string or <code>null</code>.
*
* @param context
*/
public final void setFragmentContext(@Local String context) {
this.contextName = context;
this.contextNamespace = "http://www.w3.org/1999/xhtml";
this.contextNode = null;
this.fragment = (contextName != null);
this.quirks = false;
}
// ]NOCPP]
/**
* @see nu.validator.htmlparser.common.TokenHandler#cdataSectionAllowed()
*/
@Inline public boolean cdataSectionAllowed() throws SAXException {
return isInForeign();
}
private boolean isInForeign() {
return currentPtr >= 0
&& stack[currentPtr].ns != "http://www.w3.org/1999/xhtml";
}
private boolean isInForeignButNotHtmlOrMathTextIntegrationPoint() {
if (currentPtr < 0) {
return false;
}
return !isSpecialParentInForeign(stack[currentPtr]);
}
/**
* The argument MUST be an interned string or <code>null</code>.
*
* @param context
*/
public final void setFragmentContext(@Local String context,
@NsUri String ns, T node, boolean quirks) {
// [NOCPP[
if (!((context == null && ns == null)
throw new IllegalArgumentException(
"The namespace must be the HTML, SVG or MathML namespace (or null when the local name is null). Got: "
+ ns);
}
// ]NOCPP]
this.contextName = context;
this.contextNamespace = ns;
this.contextNode = node;
this.fragment = (contextName != null);
this.quirks = quirks;
}
protected final T currentNode() {
return stack[currentPtr].node;
}
/**
* Returns the scriptingEnabled.
*
* @return the scriptingEnabled
*/
public boolean isScriptingEnabled() {
return scriptingEnabled;
}
/**
* Sets the scriptingEnabled.
*
* @param scriptingEnabled
* the scriptingEnabled to set
*/
public void setScriptingEnabled(boolean scriptingEnabled) {
this.scriptingEnabled = scriptingEnabled;
}
public void setForceNoQuirks(boolean forceNoQuirks) {
this.forceNoQuirks = forceNoQuirks;
}
// Redundant method retained because previously public.
public void setIsSrcdocDocument(boolean isSrcdocDocument) {
this.setForceNoQuirks(isSrcdocDocument);
}
public boolean isAllowDeclarativeShadowRoots() {
return allowDeclarativeShadowRoots;
}
public void setAllowDeclarativeShadowRoots(boolean allow) {
allowDeclarativeShadowRoots = allow;
}
// [NOCPP[
public void setNamePolicy(XmlViolationPolicy namePolicy) {
this.namePolicy = namePolicy;
}
/**
* Sets the documentModeHandler.
*
* @param documentModeHandler
* the documentModeHandler to set
*/
public void setDocumentModeHandler(DocumentModeHandler documentModeHandler) {
this.documentModeHandler = documentModeHandler;
}
/**
* Sets the reportingDoctype.
*
* @param reportingDoctype
* the reportingDoctype to set
*/
public void setReportingDoctype(boolean reportingDoctype) {
this.reportingDoctype = reportingDoctype;
}
// ]NOCPP]
/**
* Flushes the pending characters. Public for document.write use cases only.
* @throws SAXException
*/
public final void flushCharacters() throws SAXException {
if (charBufferLen > 0) {
if ((mode == IN_TABLE || mode == IN_TABLE_BODY || mode == IN_ROW)
&& charBufferContainsNonWhitespace()) {
errNonSpaceInTable();
reconstructTheActiveFormattingElements();
if (!stack[currentPtr].isFosterParenting()) {
// reconstructing gave us a new current node
appendCharacters(currentNode(), charBuffer, 0,
charBufferLen);
charBufferLen = 0;
return;
}
int tablePos = findLastOrRoot(TreeBuilder.TABLE);
int templatePos = findLastOrRoot(TreeBuilder.TEMPLATE);
if (templatePos >= tablePos) {
appendCharacters(stack[templatePos].node, charBuffer, 0, charBufferLen);
charBufferLen = 0;
return;
}
StackNode<T> tableElt = stack[tablePos];
insertFosterParentedCharacters(charBuffer, 0, charBufferLen,
tableElt.node, stack[tablePos - 1].node);
charBufferLen = 0;
return;
}
appendCharacters(currentNode(), charBuffer, 0, charBufferLen);
charBufferLen = 0;
}
}
private boolean charBufferContainsNonWhitespace() {
for (int i = 0; i < charBufferLen; i++) {
switch (charBuffer[i]) {
case ' ':
case '\t':
case '\n':
case '\r':
case '\u000C':
continue;
default:
return true;
}
}
return false;
}
/**
* Creates a comparable snapshot of the tree builder state. Snapshot
* creation is only supported immediately after a script end tag has been
* processed. In C++ the caller is responsible for calling
* <code>delete</code> on the returned object.
*
* @return a snapshot.
* @throws SAXException
*/
@SuppressWarnings("unchecked") public TreeBuilderState<T> newSnapshot()
throws SAXException {
StackNode<T>[] listCopy = new StackNode[listPtr + 1];
for (int i = 0; i < listCopy.length; i++) {
StackNode<T> node = listOfActiveFormattingElements[i];
if (node != null) {
StackNode<T> newNode = new StackNode<T>(-1);
newNode.setValues(node.getFlags(), node.ns,
node.name, node.node, node.popName,
node.attributes.cloneAttributes()
// CPPONLY: , node.getHtmlCreator()
// [NOCPP[
, node.getLocator()
// ]NOCPP]
);
listCopy[i] = newNode;
} else {
listCopy[i] = null;
}
}
StackNode<T>[] stackCopy = new StackNode[currentPtr + 1];
for (int i = 0; i < stackCopy.length; i++) {
StackNode<T> node = stack[i];
int listIndex = findInListOfActiveFormattingElements(node);
if (listIndex == -1) {
StackNode<T> newNode = new StackNode<T>(-1);
newNode.setValues(node.getFlags(), node.ns,
node.name, node.node, node.popName,
null
// CPPONLY: , node.getHtmlCreator()
// [NOCPP[
, node.getLocator()
// ]NOCPP]
);
stackCopy[i] = newNode;
} else {
stackCopy[i] = listCopy[listIndex];
stackCopy[i].retain();
}
}
int[] templateModeStackCopy = new int[templateModePtr + 1];
System.arraycopy(templateModeStack, 0, templateModeStackCopy, 0,
templateModeStackCopy.length);
return new StateSnapshot<T>(stackCopy, listCopy, templateModeStackCopy, formPointer,
headPointer, mode, originalMode, framesetOk,
needToDropLF, quirks);
}
public boolean snapshotMatches(TreeBuilderState<T> snapshot) {
StackNode<T>[] stackCopy = snapshot.getStack();
int stackLen = snapshot.getStackLength();
StackNode<T>[] listCopy = snapshot.getListOfActiveFormattingElements();
int listLen = snapshot.getListOfActiveFormattingElementsLength();
int[] templateModeStackCopy = snapshot.getTemplateModeStack();
int templateModeStackLen = snapshot.getTemplateModeStackLength();
if (stackLen != currentPtr + 1
|| listLen != listPtr + 1
|| templateModeStackLen != templateModePtr + 1
|| formPointer != snapshot.getFormPointer()
|| headPointer != snapshot.getHeadPointer()
|| mode != snapshot.getMode()
|| originalMode != snapshot.getOriginalMode()
|| framesetOk != snapshot.isFramesetOk()
|| needToDropLF != snapshot.isNeedToDropLF()
|| quirks != snapshot.isQuirks()) { // maybe just assert quirks
return false;
}
for (int i = listLen - 1; i >= 0; i--) {
if (listCopy[i] == null
&& listOfActiveFormattingElements[i] == null) {
continue;
} else if (listCopy[i] == null
|| listOfActiveFormattingElements[i] == null) {
return false;
}
if (listCopy[i].node != listOfActiveFormattingElements[i].node) {
return false; // it's possible that this condition is overly
// strict
}
}
for (int i = stackLen - 1; i >= 0; i--) {
if (stackCopy[i].node != stack[i].node) {
return false;
}
}
for (int i = templateModeStackLen - 1; i >=0; i--) {
if (templateModeStackCopy[i] != templateModeStack[i]) {
return false;
}
}
return true;
}
@SuppressWarnings("unchecked") public void loadState(
TreeBuilderState<T> snapshot)
throws SAXException {
// CPPONLY: mCurrentHtmlScriptCannotDocumentWriteOrBlock = false;
StackNode<T>[] stackCopy = snapshot.getStack();
int stackLen = snapshot.getStackLength();
StackNode<T>[] listCopy = snapshot.getListOfActiveFormattingElements();
int listLen = snapshot.getListOfActiveFormattingElementsLength();
int[] templateModeStackCopy = snapshot.getTemplateModeStack();
int templateModeStackLen = snapshot.getTemplateModeStackLength();
for (int i = 0; i <= listPtr; i++) {
if (listOfActiveFormattingElements[i] != null) {
listOfActiveFormattingElements[i].release(this);
}
}
if (listOfActiveFormattingElements.length < listLen) {
listOfActiveFormattingElements = new StackNode[listLen];
}
listPtr = listLen - 1;
for (int i = 0; i <= currentPtr; i++) {
stack[i].release(this);
}
if (stack.length < stackLen) {
stack = new StackNode[stackLen];
}
currentPtr = stackLen - 1;
if (templateModeStack.length < templateModeStackLen) {
templateModeStack = new int[templateModeStackLen];
}
templateModePtr = templateModeStackLen - 1;
for (int i = 0; i < listLen; i++) {
StackNode<T> node = listCopy[i];
if (node != null) {
StackNode<T> newNode = createStackNode(node.getFlags(), node.ns,
node.name, node.node,
node.popName,
node.attributes.cloneAttributes()
// CPPONLY: , node.getHtmlCreator()
// [NOCPP[
, node.getLocator()
// ]NOCPP]
);
listOfActiveFormattingElements[i] = newNode;
} else {
listOfActiveFormattingElements[i] = null;
}
}
for (int i = 0; i < stackLen; i++) {
StackNode<T> node = stackCopy[i];
int listIndex = findInArray(node, listCopy);
if (listIndex == -1) {
StackNode<T> newNode = createStackNode(node.getFlags(), node.ns,
node.name, node.node,
node.popName,
null
// CPPONLY: , node.getHtmlCreator()
// [NOCPP[
, node.getLocator()
// ]NOCPP]
);
stack[i] = newNode;
} else {
stack[i] = listOfActiveFormattingElements[listIndex];
stack[i].retain();
}
}
System.arraycopy(templateModeStackCopy, 0, templateModeStack, 0, templateModeStackLen);
formPointer = snapshot.getFormPointer();
headPointer = snapshot.getHeadPointer();
mode = snapshot.getMode();
originalMode = snapshot.getOriginalMode();
framesetOk = snapshot.isFramesetOk();
needToDropLF = snapshot.isNeedToDropLF();
quirks = snapshot.isQuirks();
}
private int findInArray(StackNode<T> node, StackNode<T>[] arr) {
for (int i = listPtr; i >= 0; i--) {
if (node == arr[i]) {
return i;
}
}
return -1;
}
/**
* Returns <code>stack[stackPos].node</code> if <code>stackPos</code> is
* smaller than Blink's magic limit or the node at Blink's magic limit
* otherwise.
*
* In order to get Blink-compatible handling of excessive deeply-nested
* markup, this method must be used to obtain the node that is used as the
* parent node of an insertion.
*
* Blink's magic number is 512, but our counting is off by one compared to
* Blink's way of counting, so in order to get the same
* externally-observable outcome, we use 511 as our magic number.
*
* @param stackPos the stack position to attempt to read
* @return node at the position capped to Blink's magic number
* @throws SAXException
*/
private T nodeFromStackWithBlinkCompat(int stackPos) throws SAXException {
// Magic number if off by one relative to Blink's magic number, but the
// outcome is the same, because the counting is different by one.
if (stackPos > 511) {
errDeepTree();
return stack[511].node;
}
return stack[stackPos].node;
}
/**
* @see nu.validator.htmlparser.impl.TreeBuilderState#getFormPointer()
*/
@Override
public T getFormPointer() {
return formPointer;
}
/**
* Returns the headPointer.
*
* @return the headPointer
*/
@Override
public T getHeadPointer() {
return headPointer;
}
/**
* @see nu.validator.htmlparser.impl.TreeBuilderState#getListOfActiveFormattingElements()
*/
@Override
public StackNode<T>[] getListOfActiveFormattingElements() {
return listOfActiveFormattingElements;
}
/**
* @see nu.validator.htmlparser.impl.TreeBuilderState#getStack()
*/
@Override
public StackNode<T>[] getStack() {
return stack;
}
/**
* @see nu.validator.htmlparser.impl.TreeBuilderState#getTemplateModeStack()
*/
@Override
public int[] getTemplateModeStack() {
return templateModeStack;
}
/**
* Returns the mode.
*
* @return the mode
*/
@Override
public int getMode() {
return mode;
}
/**
* Returns the originalMode.
*
* @return the originalMode
*/
@Override
public int getOriginalMode() {
return originalMode;
}
/**
* Returns the framesetOk.
*
* @return the framesetOk
*/
@Override
public boolean isFramesetOk() {
return framesetOk;
}
/**
* Returns the needToDropLF.
*
* @return the needToDropLF
*/
@Override
public boolean isNeedToDropLF() {
return needToDropLF;
}
/**
* Returns the quirks.
*
* @return the quirks
*/
@Override
public boolean isQuirks() {
return quirks;
}
/**
* @see nu.validator.htmlparser.impl.TreeBuilderState#getListOfActiveFormattingElementsLength()
*/
@Override
public int getListOfActiveFormattingElementsLength() {
return listPtr + 1;
}
/**
* @see nu.validator.htmlparser.impl.TreeBuilderState#getStackLength()
*/
@Override
public int getStackLength() {
return currentPtr + 1;
}
/**
* @see nu.validator.htmlparser.impl.TreeBuilderState#getTemplateModeStackLength()
*/
@Override
public int getTemplateModeStackLength() {
return templateModePtr + 1;
}
/**
* Complains about an over-deep tree. Theoretically this should just be
* a warning, but in practice authors should take this as an error.
*
* @throws SAXException
*/
private void errDeepTree() throws SAXException {
err("The document tree is more than 513 elements deep, which causes Firefox and Chrome to flatten the tree.");
}
/**
* Reports a stray start tag.
* @param name the name of the stray tag
*
* @throws SAXException
*/
private void errStrayStartTag(@Local String name) throws SAXException {
err("Stray start tag \u201C" + name + "\u201D.");
}
/**
* Reports a stray end tag.
* @param name the name of the stray tag
*
* @throws SAXException
*/
private void errStrayEndTag(@Local String name) throws SAXException {
err("Stray end tag \u201C" + name + "\u201D.");
}
/**
* Reports a state when elements expected to be closed were not.
*
* @param eltPos the position of the start tag on the stack of the element
* being closed.
* @param name the name of the end tag
*
* @throws SAXException
*/
private void errUnclosedElements(int eltPos, @Local String name) throws SAXException {
errNoCheck("End tag \u201C" + name + "\u201D seen, but there were open elements.");
errListUnclosedStartTags(eltPos);
}
/**
* Reports a state when elements expected to be closed ahead of an implied
* end tag but were not.
*
* @param eltPos the position of the start tag on the stack of the element
* being closed.
* @param name the name of the end tag
*
* @throws SAXException
*/
private void errUnclosedElementsImplied(int eltPos, String name) throws SAXException {
errNoCheck("End tag \u201C" + name + "\u201D implied, but there were open elements.");
errListUnclosedStartTags(eltPos);
}
/**
* Reports a state when elements expected to be closed ahead of an implied
* table cell close.
*
* @param eltPos the position of the start tag on the stack of the element
* being closed.
* @throws SAXException
*/
private void errUnclosedElementsCell(int eltPos) throws SAXException {
errNoCheck("A table cell was implicitly closed, but there were open elements.");
errListUnclosedStartTags(eltPos);
}
private void errStrayDoctype() throws SAXException {
err("Stray doctype.");
}
private void errAlmostStandardsDoctype() throws SAXException {
if (!forceNoQuirks) {
err("Almost standards mode doctype. Expected \u201C<!DOCTYPE html>\u201D.");
}
}
private void errQuirkyDoctype() throws SAXException {
if (!forceNoQuirks) {
err("Quirky doctype. Expected \u201C<!DOCTYPE html>\u201D.");
}
}
private void errNonSpaceInTrailer() throws SAXException {
err("Non-space character in page trailer.");
}
private void errNonSpaceAfterFrameset() throws SAXException {
err("Non-space after \u201Cframeset\u201D.");
}
private void errNonSpaceInFrameset() throws SAXException {
err("Non-space in \u201Cframeset\u201D.");
}
private void errNonSpaceAfterBody() throws SAXException {
err("Non-space character after body.");
}
private void errNonSpaceInColgroupInFragment() throws SAXException {
err("Non-space in \u201Ccolgroup\u201D when parsing fragment.");
}
private void errNonSpaceInNoscriptInHead() throws SAXException {
err("Non-space character inside \u201Cnoscript\u201D inside \u201Chead\u201D.");
}
private void errFooBetweenHeadAndBody(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("\u201C" + name + "\u201D element between \u201Chead\u201D and \u201Cbody\u201D.");
}
private void errStartTagWithoutDoctype() throws SAXException {
if (!forceNoQuirks) {
err("Start tag seen without seeing a doctype first. Expected \u201C<!DOCTYPE html>\u201D.");
}
}
private void errNoSelectInTableScope() throws SAXException {
err("No \u201Cselect\u201D in table scope.");
}
private void errStartSelectWhereEndSelectExpected() throws SAXException {
err("\u201Cselect\u201D start tag where end tag expected.");
}
private void errStartTagWithSelectOpen(@Local String name)
throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("\u201C" + name
+ "\u201D start tag with \u201Cselect\u201D open.");
}
private void errBadStartTagInNoscriptInHead(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("Bad start tag in \u201C" + name
+ "\u201D in \u201Cnoscript\u201D in \u201Chead\u201D.");
}
private void errImage() throws SAXException {
err("Saw a start tag \u201Cimage\u201D.");
}
private void errFooSeenWhenFooOpen(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("Start tag \u201C" + name + "\u201D seen but an element of the same type was already open.");
}
private void errHeadingWhenHeadingOpen() throws SAXException {
err("Heading cannot be a child of another heading.");
}
private void errFramesetStart() throws SAXException {
err("\u201Cframeset\u201D start tag seen.");
}
private void errNoCellToClose() throws SAXException {
err("No cell to close.");
}
private void errStartTagInTable(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("Start tag \u201C" + name
+ "\u201D seen in \u201Ctable\u201D.");
}
private void errFormWhenFormOpen() throws SAXException {
err("Saw a \u201Cform\u201D start tag, but there was already an active \u201Cform\u201D element. Nested forms are not allowed. Ignoring the tag.");
}
private void errTableSeenWhileTableOpen() throws SAXException {
err("Start tag for \u201Ctable\u201D seen but the previous \u201Ctable\u201D is still open.");
}
private void errStartTagInTableBody(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("\u201C" + name + "\u201D start tag in table body.");
}
private void errEndTagSeenWithoutDoctype() throws SAXException {
if (!forceNoQuirks) {
err("End tag seen without seeing a doctype first. Expected \u201C<!DOCTYPE html>\u201D.");
}
}
private void errEndTagAfterBody() throws SAXException {
err("Saw an end tag after \u201Cbody\u201D had been closed.");
}
private void errEndTagSeenWithSelectOpen(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("\u201C" + name
+ "\u201D end tag with \u201Cselect\u201D open.");
}
private void errGarbageInColgroup() throws SAXException {
err("Garbage in \u201Ccolgroup\u201D fragment.");
}
private void errEndTagBr() throws SAXException {
err("End tag \u201Cbr\u201D.");
}
private void errNoElementToCloseButEndTagSeen(@Local String name)
throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("No \u201C" + name + "\u201D element in scope but a \u201C"
+ name + "\u201D end tag seen.");
}
private void errHtmlStartTagInForeignContext(@Local String name)
throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("HTML start tag \u201C" + name
+ "\u201D in a foreign namespace context.");
}
private void errNoTableRowToClose() throws SAXException {
err("No table row to close.");
}
private void errNonSpaceInTable() throws SAXException {
err("Misplaced non-space characters inside a table.");
}
private void errUnclosedChildrenInRuby() throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("Unclosed children in \u201Cruby\u201D.");
}
private void errStartTagSeenWithoutRuby(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("Start tag \u201C"
+ name
+ "\u201D seen without a \u201Cruby\u201D element being open.");
}
private void errSelfClosing() throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("Self-closing syntax (\u201C/>\u201D) used on a non-void HTML element. Ignoring the slash and treating as a start tag.");
}
private void errNoCheckUnclosedElementsOnStack() throws SAXException {
errNoCheck("Unclosed elements on stack.");
}
private void errEndTagDidNotMatchCurrentOpenElement(@Local String name,
@Local String currOpenName) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("End tag \u201C"
+ name
+ "\u201D did not match the name of the current open element (\u201C"
+ currOpenName + "\u201D).");
}
private void errEndTagViolatesNestingRules(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("End tag \u201C" + name + "\u201D violates nesting rules.");
}
private void errEofWithUnclosedElements() throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("End of file seen and there were open elements.");
// just report all remaining unclosed elements
errListUnclosedStartTags(0);
}
/**
* Reports arriving at/near end of document with unclosed elements remaining.
*
* @param message
* the message
* @throws SAXException
*/
private void errEndWithUnclosedElements(@Local String name) throws SAXException {
if (errorHandler == null) {
return;
}
errNoCheck("End tag for \u201C"
+ name
+ "\u201D seen, but there were unclosed elements.");
// just report all remaining unclosed elements
errListUnclosedStartTags(0);
}
}