| Index: pkg/third_party/html5lib/lib/parser.dart
|
| diff --git a/pkg/third_party/html5lib/lib/parser.dart b/pkg/third_party/html5lib/lib/parser.dart
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..268053a78a1b208052a6ac57e0d0c7781bbac043
|
| --- /dev/null
|
| +++ b/pkg/third_party/html5lib/lib/parser.dart
|
| @@ -0,0 +1,3345 @@
|
| +/**
|
| + * This library has a parser for HTML5 documents, that lets you parse HTML
|
| + * easily from a script or server side application:
|
| + *
|
| + * import 'package:html5lib/parser.dart' show parse;
|
| + * import 'package:html5lib/dom.dart';
|
| + * main() {
|
| + * var document = parse(
|
| + * '<body>Hello world! <a href="www.html5rocks.com">HTML5 rocks!');
|
| + * print(document.outerHtml);
|
| + * }
|
| + *
|
| + * The resulting document you get back has a DOM-like API for easy tree
|
| + * traversal and manipulation.
|
| + */
|
| +library parser;
|
| +
|
| +import 'dart:collection';
|
| +import 'dart:math';
|
| +import 'package:source_maps/span.dart' show Span, FileSpan;
|
| +
|
| +import 'src/treebuilder.dart';
|
| +import 'src/constants.dart';
|
| +import 'src/encoding_parser.dart';
|
| +import 'src/token.dart';
|
| +import 'src/tokenizer.dart';
|
| +import 'src/utils.dart';
|
| +import 'dom.dart';
|
| +import 'dom_parsing.dart';
|
| +
|
| +/**
|
| + * Parse the [input] html5 document into a tree. The [input] can be
|
| + * a [String], [List<int>] of bytes or an [HtmlTokenizer].
|
| + *
|
| + * If [input] is not a [HtmlTokenizer], you can optionally specify the file's
|
| + * [encoding], which must be a string. If specified, that encoding will be used,
|
| + * regardless of any BOM or later declaration (such as in a meta element).
|
| + *
|
| + * Set [generateSpans] if you want to generate [Span]s, otherwise the
|
| + * [Node.sourceSpan] property will be `null`. When using [generateSpans] you can
|
| + * additionally pass [sourceUrl] to indicate where the [input] was extracted
|
| + * from.
|
| + */
|
| +Document parse(input, {String encoding, bool generateSpans: false,
|
| + String sourceUrl}) {
|
| + var p = new HtmlParser(input, encoding: encoding,
|
| + generateSpans: generateSpans, sourceUrl: sourceUrl);
|
| + return p.parse();
|
| +}
|
| +
|
| +
|
| +/**
|
| + * Parse the [input] html5 document fragment into a tree. The [input] can be
|
| + * a [String], [List<int>] of bytes or an [HtmlTokenizer]. The [container]
|
| + * element can optionally be specified, otherwise it defaults to "div".
|
| + *
|
| + * If [input] is not a [HtmlTokenizer], you can optionally specify the file's
|
| + * [encoding], which must be a string. If specified, that encoding will be used,
|
| + * regardless of any BOM or later declaration (such as in a meta element).
|
| + *
|
| + * Set [generateSpans] if you want to generate [Span]s, otherwise the
|
| + * [Node.sourceSpan] property will be `null`. When using [generateSpans] you can
|
| + * additionally pass [sourceUrl] to indicate where the [input] was extracted
|
| + * from.
|
| + */
|
| +DocumentFragment parseFragment(input, {String container: "div",
|
| + String encoding, bool generateSpans: false, String sourceUrl}) {
|
| + var p = new HtmlParser(input, encoding: encoding,
|
| + generateSpans: generateSpans, sourceUrl: sourceUrl);
|
| + return p.parseFragment(container);
|
| +}
|
| +
|
| +
|
| +/**
|
| + * Parser for HTML, which generates a tree structure from a stream of
|
| + * (possibly malformed) characters.
|
| + */
|
| +class HtmlParser {
|
| + /** Raise an exception on the first error encountered. */
|
| + final bool strict;
|
| +
|
| + /** True to generate [Span]s for the [Node.sourceSpan] property. */
|
| + final bool generateSpans;
|
| +
|
| + final HtmlTokenizer tokenizer;
|
| +
|
| + final TreeBuilder tree;
|
| +
|
| + final List<ParseError> errors = <ParseError>[];
|
| +
|
| + String container;
|
| +
|
| + bool firstStartTag = false;
|
| +
|
| + // TODO(jmesserly): use enum?
|
| + /** "quirks" / "limited quirks" / "no quirks" */
|
| + String compatMode = "no quirks";
|
| +
|
| + /** innerHTML container when parsing document fragment. */
|
| + String innerHTML;
|
| +
|
| + Phase phase;
|
| +
|
| + Phase lastPhase;
|
| +
|
| + Phase originalPhase;
|
| +
|
| + Phase beforeRCDataPhase;
|
| +
|
| + bool framesetOK;
|
| +
|
| + // These fields hold the different phase singletons. At any given time one
|
| + // of them will be active.
|
| + InitialPhase _initialPhase;
|
| + BeforeHtmlPhase _beforeHtmlPhase;
|
| + BeforeHeadPhase _beforeHeadPhase;
|
| + InHeadPhase _inHeadPhase;
|
| + AfterHeadPhase _afterHeadPhase;
|
| + InBodyPhase _inBodyPhase;
|
| + TextPhase _textPhase;
|
| + InTablePhase _inTablePhase;
|
| + InTableTextPhase _inTableTextPhase;
|
| + InCaptionPhase _inCaptionPhase;
|
| + InColumnGroupPhase _inColumnGroupPhase;
|
| + InTableBodyPhase _inTableBodyPhase;
|
| + InRowPhase _inRowPhase;
|
| + InCellPhase _inCellPhase;
|
| + InSelectPhase _inSelectPhase;
|
| + InSelectInTablePhase _inSelectInTablePhase;
|
| + InForeignContentPhase _inForeignContentPhase;
|
| + AfterBodyPhase _afterBodyPhase;
|
| + InFramesetPhase _inFramesetPhase;
|
| + AfterFramesetPhase _afterFramesetPhase;
|
| + AfterAfterBodyPhase _afterAfterBodyPhase;
|
| + AfterAfterFramesetPhase _afterAfterFramesetPhase;
|
| +
|
| + /**
|
| + * Create a new HtmlParser and configure the [tree] builder and [strict] mode.
|
| + * The [input] can be a [String], [List<int>] of bytes or an [HtmlTokenizer].
|
| + *
|
| + * If [input] is not a [HtmlTokenizer], you can specify a few more arguments.
|
| + *
|
| + * The [encoding] must be a string that indicates the encoding. If specified,
|
| + * that encoding will be used, regardless of any BOM or later declaration
|
| + * (such as in a meta element).
|
| + *
|
| + * Set [parseMeta] to false if you want to disable parsing the meta element.
|
| + *
|
| + * Set [lowercaseElementName] or [lowercaseAttrName] to false to disable the
|
| + * automatic conversion of element and attribute names to lower case. Note
|
| + * that standard way to parse HTML is to lowercase, which is what the browser
|
| + * DOM will do if you request [Node.outerHTML], for example.
|
| + */
|
| + HtmlParser(input, {String encoding, bool parseMeta: true,
|
| + bool lowercaseElementName: true, bool lowercaseAttrName: true,
|
| + this.strict: false, bool generateSpans: false, String sourceUrl,
|
| + TreeBuilder tree})
|
| + : generateSpans = generateSpans,
|
| + tree = tree != null ? tree : new TreeBuilder(true),
|
| + tokenizer = (input is HtmlTokenizer ? input :
|
| + new HtmlTokenizer(input, encoding: encoding, parseMeta: parseMeta,
|
| + lowercaseElementName: lowercaseElementName,
|
| + lowercaseAttrName: lowercaseAttrName,
|
| + generateSpans: generateSpans, sourceUrl: sourceUrl)) {
|
| +
|
| + tokenizer.parser = this;
|
| + _initialPhase = new InitialPhase(this);
|
| + _beforeHtmlPhase = new BeforeHtmlPhase(this);
|
| + _beforeHeadPhase = new BeforeHeadPhase(this);
|
| + _inHeadPhase = new InHeadPhase(this);
|
| + // TODO(jmesserly): html5lib did not implement the no script parsing mode
|
| + // More information here:
|
| + // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#scripting-flag
|
| + // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#parsing-main-inheadnoscript
|
| + // "inHeadNoscript": new InHeadNoScriptPhase(this);
|
| + _afterHeadPhase = new AfterHeadPhase(this);
|
| + _inBodyPhase = new InBodyPhase(this);
|
| + _textPhase = new TextPhase(this);
|
| + _inTablePhase = new InTablePhase(this);
|
| + _inTableTextPhase = new InTableTextPhase(this);
|
| + _inCaptionPhase = new InCaptionPhase(this);
|
| + _inColumnGroupPhase = new InColumnGroupPhase(this);
|
| + _inTableBodyPhase = new InTableBodyPhase(this);
|
| + _inRowPhase = new InRowPhase(this);
|
| + _inCellPhase = new InCellPhase(this);
|
| + _inSelectPhase = new InSelectPhase(this);
|
| + _inSelectInTablePhase = new InSelectInTablePhase(this);
|
| + _inForeignContentPhase = new InForeignContentPhase(this);
|
| + _afterBodyPhase = new AfterBodyPhase(this);
|
| + _inFramesetPhase = new InFramesetPhase(this);
|
| + _afterFramesetPhase = new AfterFramesetPhase(this);
|
| + _afterAfterBodyPhase = new AfterAfterBodyPhase(this);
|
| + _afterAfterFramesetPhase = new AfterAfterFramesetPhase(this);
|
| + }
|
| +
|
| + bool get innerHTMLMode => innerHTML != null;
|
| +
|
| + /**
|
| + * Parse an html5 document into a tree.
|
| + * After parsing, [errors] will be populated with parse errors, if any.
|
| + */
|
| + Document parse() {
|
| + innerHTML = null;
|
| + _parse();
|
| + return tree.getDocument();
|
| + }
|
| +
|
| + /**
|
| + * Parse an html5 document fragment into a tree.
|
| + * Pass a [container] to change the type of the containing element.
|
| + * After parsing, [errors] will be populated with parse errors, if any.
|
| + */
|
| + DocumentFragment parseFragment([String container = "div"]) {
|
| + if (container == null) throw new ArgumentError('container');
|
| + innerHTML = container.toLowerCase();
|
| + _parse();
|
| + return tree.getFragment();
|
| + }
|
| +
|
| + void _parse() {
|
| + reset();
|
| +
|
| + while (true) {
|
| + try {
|
| + mainLoop();
|
| + break;
|
| + } on ReparseException catch (e) {
|
| + // Note: this happens if we start parsing but the character encoding
|
| + // changes. So we should only need to restart very early in the parse.
|
| + reset();
|
| + }
|
| + }
|
| + }
|
| +
|
| + void reset() {
|
| + tokenizer.reset();
|
| +
|
| + tree.reset();
|
| + firstStartTag = false;
|
| + errors.clear();
|
| + // "quirks" / "limited quirks" / "no quirks"
|
| + compatMode = "no quirks";
|
| +
|
| + if (innerHTMLMode) {
|
| + if (cdataElements.contains(innerHTML)) {
|
| + tokenizer.state = tokenizer.rcdataState;
|
| + } else if (rcdataElements.contains(innerHTML)) {
|
| + tokenizer.state = tokenizer.rawtextState;
|
| + } else if (innerHTML == 'plaintext') {
|
| + tokenizer.state = tokenizer.plaintextState;
|
| + } else {
|
| + // state already is data state
|
| + // tokenizer.state = tokenizer.dataState;
|
| + }
|
| + phase = _beforeHtmlPhase;
|
| + _beforeHtmlPhase.insertHtmlElement();
|
| + resetInsertionMode();
|
| + } else {
|
| + phase = _initialPhase;
|
| + }
|
| +
|
| + lastPhase = null;
|
| + beforeRCDataPhase = null;
|
| + framesetOK = true;
|
| + }
|
| +
|
| + bool isHTMLIntegrationPoint(Node element) {
|
| + if (element.tagName == "annotation-xml" &&
|
| + element.namespace == Namespaces.mathml) {
|
| + var enc = element.attributes["encoding"];
|
| + if (enc != null) enc = asciiUpper2Lower(enc);
|
| + return enc == "text/html" || enc == "application/xhtml+xml";
|
| + } else {
|
| + return htmlIntegrationPointElements.contains(
|
| + new Pair(element.namespace, element.tagName));
|
| + }
|
| + }
|
| +
|
| + bool isMathMLTextIntegrationPoint(Node element) {
|
| + return mathmlTextIntegrationPointElements.contains(
|
| + new Pair(element.namespace, element.tagName));
|
| + }
|
| +
|
| + bool inForeignContent(Token token, int type) {
|
| + if (tree.openElements.length == 0) return false;
|
| +
|
| + var node = tree.openElements.last;
|
| + if (node.namespace == tree.defaultNamespace) return false;
|
| +
|
| + if (isMathMLTextIntegrationPoint(node)) {
|
| + if (type == TokenKind.startTag &&
|
| + (token as StartTagToken).name != "mglyph" &&
|
| + (token as StartTagToken).name != "malignmark") {
|
| + return false;
|
| + }
|
| + if (type == TokenKind.characters || type == TokenKind.spaceCharacters) {
|
| + return false;
|
| + }
|
| + }
|
| +
|
| + if (node.tagName == "annotation-xml" && type == TokenKind.startTag &&
|
| + (token as StartTagToken).name == "svg") {
|
| + return false;
|
| + }
|
| +
|
| + if (isHTMLIntegrationPoint(node)) {
|
| + if (type == TokenKind.startTag ||
|
| + type == TokenKind.characters ||
|
| + type == TokenKind.spaceCharacters) {
|
| + return false;
|
| + }
|
| + }
|
| +
|
| + return true;
|
| + }
|
| +
|
| + void mainLoop() {
|
| + while (tokenizer.moveNext()) {
|
| + var token = tokenizer.current;
|
| + var newToken = token;
|
| + int type;
|
| + while (newToken != null) {
|
| + type = newToken.kind;
|
| +
|
| + // Note: avoid "is" test here, see http://dartbug.com/4795
|
| + if (type == TokenKind.parseError) {
|
| + ParseErrorToken error = newToken;
|
| + parseError(error.span, error.data, error.messageParams);
|
| + newToken = null;
|
| + } else {
|
| + Phase phase_ = phase;
|
| + if (inForeignContent(token, type)) {
|
| + phase_ = _inForeignContentPhase;
|
| + }
|
| +
|
| + switch (type) {
|
| + case TokenKind.characters:
|
| + newToken = phase_.processCharacters(newToken);
|
| + break;
|
| + case TokenKind.spaceCharacters:
|
| + newToken = phase_.processSpaceCharacters(newToken);
|
| + break;
|
| + case TokenKind.startTag:
|
| + newToken = phase_.processStartTag(newToken);
|
| + break;
|
| + case TokenKind.endTag:
|
| + newToken = phase_.processEndTag(newToken);
|
| + break;
|
| + case TokenKind.comment:
|
| + newToken = phase_.processComment(newToken);
|
| + break;
|
| + case TokenKind.doctype:
|
| + newToken = phase_.processDoctype(newToken);
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + if (token is StartTagToken) {
|
| + if (token.selfClosing && !token.selfClosingAcknowledged) {
|
| + parseError(token.span, "non-void-element-with-trailing-solidus",
|
| + {"name": token.name});
|
| + }
|
| + }
|
| + }
|
| +
|
| + // When the loop finishes it's EOF
|
| + var reprocess = true;
|
| + var reprocessPhases = [];
|
| + while (reprocess) {
|
| + reprocessPhases.add(phase);
|
| + reprocess = phase.processEOF();
|
| + if (reprocess) {
|
| + assert(!reprocessPhases.contains(phase));
|
| + }
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * The last span available. Used for EOF errors if we don't have something
|
| + * better.
|
| + */
|
| + Span get _lastSpan {
|
| + var pos = tokenizer.stream.position;
|
| + return new FileSpan(tokenizer.stream.fileInfo, pos, pos);
|
| + }
|
| +
|
| + void parseError(Span span, String errorcode,
|
| + [Map datavars = const {}]) {
|
| +
|
| + if (!generateSpans && span == null) {
|
| + span = _lastSpan;
|
| + }
|
| +
|
| + var err = new ParseError(errorcode, span, datavars);
|
| + errors.add(err);
|
| + if (strict) throw err;
|
| + }
|
| +
|
| + void adjustMathMLAttributes(StartTagToken token) {
|
| + var orig = token.data.remove("definitionurl");
|
| + if (orig != null) {
|
| + token.data["definitionURL"] = orig;
|
| + }
|
| + }
|
| +
|
| + void adjustSVGAttributes(StartTagToken token) {
|
| + final replacements = const {
|
| + "attributename":"attributeName",
|
| + "attributetype":"attributeType",
|
| + "basefrequency":"baseFrequency",
|
| + "baseprofile":"baseProfile",
|
| + "calcmode":"calcMode",
|
| + "clippathunits":"clipPathUnits",
|
| + "contentscripttype":"contentScriptType",
|
| + "contentstyletype":"contentStyleType",
|
| + "diffuseconstant":"diffuseConstant",
|
| + "edgemode":"edgeMode",
|
| + "externalresourcesrequired":"externalResourcesRequired",
|
| + "filterres":"filterRes",
|
| + "filterunits":"filterUnits",
|
| + "glyphref":"glyphRef",
|
| + "gradienttransform":"gradientTransform",
|
| + "gradientunits":"gradientUnits",
|
| + "kernelmatrix":"kernelMatrix",
|
| + "kernelunitlength":"kernelUnitLength",
|
| + "keypoints":"keyPoints",
|
| + "keysplines":"keySplines",
|
| + "keytimes":"keyTimes",
|
| + "lengthadjust":"lengthAdjust",
|
| + "limitingconeangle":"limitingConeAngle",
|
| + "markerheight":"markerHeight",
|
| + "markerunits":"markerUnits",
|
| + "markerwidth":"markerWidth",
|
| + "maskcontentunits":"maskContentUnits",
|
| + "maskunits":"maskUnits",
|
| + "numoctaves":"numOctaves",
|
| + "pathlength":"pathLength",
|
| + "patterncontentunits":"patternContentUnits",
|
| + "patterntransform":"patternTransform",
|
| + "patternunits":"patternUnits",
|
| + "pointsatx":"pointsAtX",
|
| + "pointsaty":"pointsAtY",
|
| + "pointsatz":"pointsAtZ",
|
| + "preservealpha":"preserveAlpha",
|
| + "preserveaspectratio":"preserveAspectRatio",
|
| + "primitiveunits":"primitiveUnits",
|
| + "refx":"refX",
|
| + "refy":"refY",
|
| + "repeatcount":"repeatCount",
|
| + "repeatdur":"repeatDur",
|
| + "requiredextensions":"requiredExtensions",
|
| + "requiredfeatures":"requiredFeatures",
|
| + "specularconstant":"specularConstant",
|
| + "specularexponent":"specularExponent",
|
| + "spreadmethod":"spreadMethod",
|
| + "startoffset":"startOffset",
|
| + "stddeviation":"stdDeviation",
|
| + "stitchtiles":"stitchTiles",
|
| + "surfacescale":"surfaceScale",
|
| + "systemlanguage":"systemLanguage",
|
| + "tablevalues":"tableValues",
|
| + "targetx":"targetX",
|
| + "targety":"targetY",
|
| + "textlength":"textLength",
|
| + "viewbox":"viewBox",
|
| + "viewtarget":"viewTarget",
|
| + "xchannelselector":"xChannelSelector",
|
| + "ychannelselector":"yChannelSelector",
|
| + "zoomandpan":"zoomAndPan"
|
| + };
|
| + for (var originalName in token.data.keys.toList()) {
|
| + var svgName = replacements[originalName];
|
| + if (svgName != null) {
|
| + token.data[svgName] = token.data.remove(originalName);
|
| + }
|
| + }
|
| + }
|
| +
|
| + void adjustForeignAttributes(StartTagToken token) {
|
| + // TODO(jmesserly): I don't like mixing non-string objects with strings in
|
| + // the Node.attributes Map. Is there another solution?
|
| + final replacements = const {
|
| + "xlink:actuate": const AttributeName("xlink", "actuate",
|
| + Namespaces.xlink),
|
| + "xlink:arcrole": const AttributeName("xlink", "arcrole",
|
| + Namespaces.xlink),
|
| + "xlink:href": const AttributeName("xlink", "href", Namespaces.xlink),
|
| + "xlink:role": const AttributeName("xlink", "role", Namespaces.xlink),
|
| + "xlink:show": const AttributeName("xlink", "show", Namespaces.xlink),
|
| + "xlink:title": const AttributeName("xlink", "title", Namespaces.xlink),
|
| + "xlink:type": const AttributeName("xlink", "type", Namespaces.xlink),
|
| + "xml:base": const AttributeName("xml", "base", Namespaces.xml),
|
| + "xml:lang": const AttributeName("xml", "lang", Namespaces.xml),
|
| + "xml:space": const AttributeName("xml", "space", Namespaces.xml),
|
| + "xmlns": const AttributeName(null, "xmlns", Namespaces.xmlns),
|
| + "xmlns:xlink": const AttributeName("xmlns", "xlink", Namespaces.xmlns)
|
| + };
|
| +
|
| + for (var originalName in token.data.keys.toList()) {
|
| + var foreignName = replacements[originalName];
|
| + if (foreignName != null) {
|
| + token.data[foreignName] = token.data.remove(originalName);
|
| + }
|
| + }
|
| + }
|
| +
|
| + void resetInsertionMode() {
|
| + // The name of this method is mostly historical. (It's also used in the
|
| + // specification.)
|
| + for (Node node in tree.openElements.reversed) {
|
| + var nodeName = node.tagName;
|
| + bool last = node == tree.openElements[0];
|
| + if (last) {
|
| + assert(innerHTMLMode);
|
| + nodeName = innerHTML;
|
| + }
|
| + // Check for conditions that should only happen in the innerHTML
|
| + // case
|
| + switch (nodeName) {
|
| + case "select": case "colgroup": case "head": case "html":
|
| + assert(innerHTMLMode);
|
| + break;
|
| + }
|
| + if (!last && node.namespace != tree.defaultNamespace) {
|
| + continue;
|
| + }
|
| + switch (nodeName) {
|
| + case "select": phase = _inSelectPhase; return;
|
| + case "td": phase = _inCellPhase; return;
|
| + case "th": phase = _inCellPhase; return;
|
| + case "tr": phase = _inRowPhase; return;
|
| + case "tbody": phase = _inTableBodyPhase; return;
|
| + case "thead": phase = _inTableBodyPhase; return;
|
| + case "tfoot": phase = _inTableBodyPhase; return;
|
| + case "caption": phase = _inCaptionPhase; return;
|
| + case "colgroup": phase = _inColumnGroupPhase; return;
|
| + case "table": phase = _inTablePhase; return;
|
| + case "head": phase = _inBodyPhase; return;
|
| + case "body": phase = _inBodyPhase; return;
|
| + case "frameset": phase = _inFramesetPhase; return;
|
| + case "html": phase = _beforeHeadPhase; return;
|
| + }
|
| + }
|
| + phase = _inBodyPhase;
|
| + }
|
| +
|
| + /**
|
| + * Generic RCDATA/RAWTEXT Parsing algorithm
|
| + * [contentType] - RCDATA or RAWTEXT
|
| + */
|
| + void parseRCDataRawtext(Token token, String contentType) {
|
| + assert(contentType == "RAWTEXT" || contentType == "RCDATA");
|
| +
|
| + var element = tree.insertElement(token);
|
| +
|
| + if (contentType == "RAWTEXT") {
|
| + tokenizer.state = tokenizer.rawtextState;
|
| + } else {
|
| + tokenizer.state = tokenizer.rcdataState;
|
| + }
|
| +
|
| + originalPhase = phase;
|
| + phase = _textPhase;
|
| + }
|
| +}
|
| +
|
| +
|
| +/** Base class for helper object that implements each phase of processing. */
|
| +class Phase {
|
| + // Order should be (they can be omitted):
|
| + // * EOF
|
| + // * Comment
|
| + // * Doctype
|
| + // * SpaceCharacters
|
| + // * Characters
|
| + // * StartTag
|
| + // - startTag* methods
|
| + // * EndTag
|
| + // - endTag* methods
|
| +
|
| + final HtmlParser parser;
|
| +
|
| + final TreeBuilder tree;
|
| +
|
| + Phase(HtmlParser parser) : parser = parser, tree = parser.tree;
|
| +
|
| + bool processEOF() {
|
| + throw new UnimplementedError();
|
| + }
|
| +
|
| + Token processComment(CommentToken token) {
|
| + // For most phases the following is correct. Where it's not it will be
|
| + // overridden.
|
| + tree.insertComment(token, tree.openElements.last);
|
| + }
|
| +
|
| + Token processDoctype(DoctypeToken token) {
|
| + parser.parseError(token.span, "unexpected-doctype");
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + tree.insertText(token.data, token.span);
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + tree.insertText(token.data, token.span);
|
| + }
|
| +
|
| + Token processStartTag(StartTagToken token) {
|
| + throw new UnimplementedError();
|
| + }
|
| +
|
| + Token startTagHtml(StartTagToken token) {
|
| + if (parser.firstStartTag == false && token.name == "html") {
|
| + parser.parseError(token.span, "non-html-root");
|
| + }
|
| + // XXX Need a check here to see if the first start tag token emitted is
|
| + // this token... If it's not, invoke parser.parseError().
|
| + token.data.forEach((attr, value) {
|
| + tree.openElements[0].attributes.putIfAbsent(attr, () => value);
|
| + });
|
| + parser.firstStartTag = false;
|
| + }
|
| +
|
| + Token processEndTag(EndTagToken token) {
|
| + throw new UnimplementedError();
|
| + }
|
| +
|
| + /** Helper method for popping openElements. */
|
| + void popOpenElementsUntil(String name) {
|
| + var node = tree.openElements.removeLast();
|
| + while (node.tagName != name) {
|
| + node = tree.openElements.removeLast();
|
| + }
|
| + }
|
| +}
|
| +
|
| +class InitialPhase extends Phase {
|
| + InitialPhase(parser) : super(parser);
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + }
|
| +
|
| + Token processComment(CommentToken token) {
|
| + tree.insertComment(token, tree.document);
|
| + }
|
| +
|
| + Token processDoctype(DoctypeToken token) {
|
| + var name = token.name;
|
| + String publicId = token.publicId;
|
| + var systemId = token.systemId;
|
| + var correct = token.correct;
|
| +
|
| + if ((name != "html" || publicId != null ||
|
| + systemId != null && systemId != "about:legacy-compat")) {
|
| + parser.parseError(token.span, "unknown-doctype");
|
| + }
|
| +
|
| + if (publicId == null) {
|
| + publicId = "";
|
| + }
|
| +
|
| + tree.insertDoctype(token);
|
| +
|
| + if (publicId != "") {
|
| + publicId = asciiUpper2Lower(publicId);
|
| + }
|
| +
|
| + if (!correct || token.name != "html"
|
| + || startsWithAny(publicId, const [
|
| + "+//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//"])
|
| + || const ["-//w3o//dtd w3 html strict 3.0//en//",
|
| + "-/w3c/dtd html 4.0 transitional/en",
|
| + "html"].contains(publicId)
|
| + || startsWithAny(publicId, const [
|
| + "-//w3c//dtd html 4.01 frameset//",
|
| + "-//w3c//dtd html 4.01 transitional//"]) && systemId == null
|
| + || systemId != null && systemId.toLowerCase() ==
|
| + "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {
|
| +
|
| + parser.compatMode = "quirks";
|
| + } else if (startsWithAny(publicId, const [
|
| + "-//w3c//dtd xhtml 1.0 frameset//",
|
| + "-//w3c//dtd xhtml 1.0 transitional//"])
|
| + || startsWithAny(publicId, const [
|
| + "-//w3c//dtd html 4.01 frameset//",
|
| + "-//w3c//dtd html 4.01 transitional//"]) &&
|
| + systemId != null) {
|
| + parser.compatMode = "limited quirks";
|
| + }
|
| + parser.phase = parser._beforeHtmlPhase;
|
| + }
|
| +
|
| + void anythingElse() {
|
| + parser.compatMode = "quirks";
|
| + parser.phase = parser._beforeHtmlPhase;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + parser.parseError(token.span, "expected-doctype-but-got-chars");
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + Token processStartTag(StartTagToken token) {
|
| + parser.parseError(token.span, "expected-doctype-but-got-start-tag",
|
| + {"name": token.name});
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + Token processEndTag(EndTagToken token) {
|
| + parser.parseError(token.span, "expected-doctype-but-got-end-tag",
|
| + {"name": token.name});
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + bool processEOF() {
|
| + parser.parseError(parser._lastSpan, "expected-doctype-but-got-eof");
|
| + anythingElse();
|
| + return true;
|
| + }
|
| +}
|
| +
|
| +
|
| +class BeforeHtmlPhase extends Phase {
|
| + BeforeHtmlPhase(parser) : super(parser);
|
| +
|
| + // helper methods
|
| + void insertHtmlElement() {
|
| + tree.insertRoot(new StartTagToken("html", data: {}));
|
| + parser.phase = parser._beforeHeadPhase;
|
| + }
|
| +
|
| + // other
|
| + bool processEOF() {
|
| + insertHtmlElement();
|
| + return true;
|
| + }
|
| +
|
| + Token processComment(CommentToken token) {
|
| + tree.insertComment(token, tree.document);
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + insertHtmlElement();
|
| + return token;
|
| + }
|
| +
|
| + Token processStartTag(StartTagToken token) {
|
| + if (token.name == "html") {
|
| + parser.firstStartTag = true;
|
| + }
|
| + insertHtmlElement();
|
| + return token;
|
| + }
|
| +
|
| + Token processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "head": case "body": case "html": case "br":
|
| + insertHtmlElement();
|
| + return token;
|
| + default:
|
| + parser.parseError(token.span, "unexpected-end-tag-before-html",
|
| + {"name": token.name});
|
| + return null;
|
| + }
|
| + }
|
| +}
|
| +
|
| +
|
| +class BeforeHeadPhase extends Phase {
|
| + BeforeHeadPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case 'html': return startTagHtml(token);
|
| + case 'head': return startTagHead(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "head": case "body": case "html": case "br":
|
| + return endTagImplyHead(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool processEOF() {
|
| + startTagHead(new StartTagToken("head", data: {}));
|
| + return true;
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + startTagHead(new StartTagToken("head", data: {}));
|
| + return token;
|
| + }
|
| +
|
| + Token startTagHtml(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + void startTagHead(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + tree.headPointer = tree.openElements.last;
|
| + parser.phase = parser._inHeadPhase;
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + startTagHead(new StartTagToken("head", data: {}));
|
| + return token;
|
| + }
|
| +
|
| + Token endTagImplyHead(EndTagToken token) {
|
| + startTagHead(new StartTagToken("head", data: {}));
|
| + return token;
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "end-tag-after-implied-root",
|
| + {"name": token.name});
|
| + }
|
| +}
|
| +
|
| +class InHeadPhase extends Phase {
|
| + InHeadPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "title": return startTagTitle(token);
|
| + case "noscript": case "noframes": case "style":
|
| + return startTagNoScriptNoFramesStyle(token);
|
| + case "script": return startTagScript(token);
|
| + case "base": case "basefont": case "bgsound": case "command": case "link":
|
| + return startTagBaseLinkCommand(token);
|
| + case "meta": return startTagMeta(token);
|
| + case "head": return startTagHead(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "head": return endTagHead(token);
|
| + case "br": case "html": case "body": return endTagHtmlBodyBr(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + // the real thing
|
| + bool processEOF() {
|
| + anythingElse();
|
| + return true;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + Token startTagHtml(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + void startTagHead(StartTagToken token) {
|
| + parser.parseError(token.span, "two-heads-are-not-better-than-one");
|
| + }
|
| +
|
| + void startTagBaseLinkCommand(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| + }
|
| +
|
| + void startTagMeta(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| +
|
| + var attributes = token.data;
|
| + if (!parser.tokenizer.stream.charEncodingCertain) {
|
| + var charset = attributes["charset"];
|
| + var content = attributes["content"];
|
| + if (charset != null) {
|
| + parser.tokenizer.stream.changeEncoding(charset);
|
| + } else if (content != null) {
|
| + var data = new EncodingBytes(content);
|
| + var codec = new ContentAttrParser(data).parse();
|
| + parser.tokenizer.stream.changeEncoding(codec);
|
| + }
|
| + }
|
| + }
|
| +
|
| + void startTagTitle(StartTagToken token) {
|
| + parser.parseRCDataRawtext(token, "RCDATA");
|
| + }
|
| +
|
| + void startTagNoScriptNoFramesStyle(StartTagToken token) {
|
| + // Need to decide whether to implement the scripting-disabled case
|
| + parser.parseRCDataRawtext(token, "RAWTEXT");
|
| + }
|
| +
|
| + void startTagScript(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + parser.tokenizer.state = parser.tokenizer.scriptDataState;
|
| + parser.originalPhase = parser.phase;
|
| + parser.phase = parser._textPhase;
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + void endTagHead(EndTagToken token) {
|
| + var node = parser.tree.openElements.removeLast();
|
| + assert(node.tagName == "head");
|
| + parser.phase = parser._afterHeadPhase;
|
| + }
|
| +
|
| + Token endTagHtmlBodyBr(EndTagToken token) {
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + }
|
| +
|
| + void anythingElse() {
|
| + endTagHead(new EndTagToken("head"));
|
| + }
|
| +}
|
| +
|
| +
|
| +// XXX If we implement a parser for which scripting is disabled we need to
|
| +// implement this phase.
|
| +//
|
| +// class InHeadNoScriptPhase extends Phase {
|
| +
|
| +class AfterHeadPhase extends Phase {
|
| + AfterHeadPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "body": return startTagBody(token);
|
| + case "frameset": return startTagFrameset(token);
|
| + case "base": case "basefont": case "bgsound": case "link": case "meta":
|
| + case "noframes": case "script": case "style": case "title":
|
| + return startTagFromHead(token);
|
| + case "head": return startTagHead(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "body": case "html": case "br":
|
| + return endTagHtmlBodyBr(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool processEOF() {
|
| + anythingElse();
|
| + return true;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + Token startTagHtml(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + void startTagBody(StartTagToken token) {
|
| + parser.framesetOK = false;
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inBodyPhase;
|
| + }
|
| +
|
| + void startTagFrameset(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inFramesetPhase;
|
| + }
|
| +
|
| + void startTagFromHead(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-out-of-my-head",
|
| + {"name": token.name});
|
| + tree.openElements.add(tree.headPointer);
|
| + parser._inHeadPhase.processStartTag(token);
|
| + for (Node node in tree.openElements.reversed) {
|
| + if (node.tagName == "head") {
|
| + tree.openElements.remove(node);
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + void startTagHead(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag", {"name": token.name});
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + Token endTagHtmlBodyBr(EndTagToken token) {
|
| + anythingElse();
|
| + return token;
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + }
|
| +
|
| + void anythingElse() {
|
| + tree.insertElement(new StartTagToken("body", data: {}));
|
| + parser.phase = parser._inBodyPhase;
|
| + parser.framesetOK = true;
|
| + }
|
| +}
|
| +
|
| +typedef Token TokenProccessor(Token token);
|
| +
|
| +class InBodyPhase extends Phase {
|
| + bool dropNewline = false;
|
| +
|
| + // http://www.whatwg.org/specs/web-apps/current-work///parsing-main-inbody
|
| + // the really-really-really-very crazy mode
|
| + InBodyPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html":
|
| + return startTagHtml(token);
|
| + case "base": case "basefont": case "bgsound": case "command": case "link":
|
| + case "meta": case "noframes": case "script": case "style": case "title":
|
| + return startTagProcessInHead(token);
|
| + case "body":
|
| + return startTagBody(token);
|
| + case "frameset":
|
| + return startTagFrameset(token);
|
| + case "address": case "article": case "aside": case "blockquote":
|
| + case "center": case "details": case "details": case "dir": case "div":
|
| + case "dl": case "fieldset": case "figcaption": case "figure":
|
| + case "footer": case "header": case "hgroup": case "menu": case "nav":
|
| + case "ol": case "p": case "section": case "summary": case "ul":
|
| + return startTagCloseP(token);
|
| + // headingElements
|
| + case "h1": case "h2": case "h3": case "h4": case "h5": case "h6":
|
| + return startTagHeading(token);
|
| + case "pre": case "listing":
|
| + return startTagPreListing(token);
|
| + case "form":
|
| + return startTagForm(token);
|
| + case "li": case "dd": case "dt":
|
| + return startTagListItem(token);
|
| + case "plaintext":
|
| + return startTagPlaintext(token);
|
| + case "a": return startTagA(token);
|
| + case "b": case "big": case "code": case "em": case "font": case "i":
|
| + case "s": case "small": case "strike": case "strong": case "tt": case "u":
|
| + return startTagFormatting(token);
|
| + case "nobr":
|
| + return startTagNobr(token);
|
| + case "button":
|
| + return startTagButton(token);
|
| + case "applet": case "marquee": case "object":
|
| + return startTagAppletMarqueeObject(token);
|
| + case "xmp":
|
| + return startTagXmp(token);
|
| + case "table":
|
| + return startTagTable(token);
|
| + case "area": case "br": case "embed": case "img": case "keygen":
|
| + case "wbr":
|
| + return startTagVoidFormatting(token);
|
| + case "param": case "source": case "track":
|
| + return startTagParamSource(token);
|
| + case "input":
|
| + return startTagInput(token);
|
| + case "hr":
|
| + return startTagHr(token);
|
| + case "image":
|
| + return startTagImage(token);
|
| + case "isindex":
|
| + return startTagIsIndex(token);
|
| + case "textarea":
|
| + return startTagTextarea(token);
|
| + case "iframe":
|
| + return startTagIFrame(token);
|
| + case "noembed": case "noframes": case "noscript":
|
| + return startTagRawtext(token);
|
| + case "select":
|
| + return startTagSelect(token);
|
| + case "rp": case "rt":
|
| + return startTagRpRt(token);
|
| + case "option": case "optgroup":
|
| + return startTagOpt(token);
|
| + case "math":
|
| + return startTagMath(token);
|
| + case "svg":
|
| + return startTagSvg(token);
|
| + case "caption": case "col": case "colgroup": case "frame": case "head":
|
| + case "tbody": case "td": case "tfoot": case "th": case "thead": case "tr":
|
| + return startTagMisplaced(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "body": return endTagBody(token);
|
| + case "html": return endTagHtml(token);
|
| + case "address": case "article": case "aside": case "blockquote":
|
| + case "center": case "details": case "dir": case "div": case "dl":
|
| + case "fieldset": case "figcaption": case "figure": case "footer":
|
| + case "header": case "hgroup": case "listing": case "menu": case "nav":
|
| + case "ol": case "pre": case "section": case "summary": case "ul":
|
| + return endTagBlock(token);
|
| + case "form": return endTagForm(token);
|
| + case "p": return endTagP(token);
|
| + case "dd": case "dt": case "li": return endTagListItem(token);
|
| + // headingElements
|
| + case "h1": case "h2": case "h3": case "h4": case "h5": case "h6":
|
| + return endTagHeading(token);
|
| + case "a": case "b": case "big": case "code": case "em": case "font":
|
| + case "i": case "nobr": case "s": case "small": case "strike":
|
| + case "strong": case "tt": case "u":
|
| + return endTagFormatting(token);
|
| + case "applet": case "marquee": case "object":
|
| + return endTagAppletMarqueeObject(token);
|
| + case "br": return endTagBr(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool isMatchingFormattingElement(Node node1, Node node2) {
|
| + if (node1.tagName != node2.tagName || node1.namespace != node2.namespace) {
|
| + return false;
|
| + } else if (node1.attributes.length != node2.attributes.length) {
|
| + return false;
|
| + } else {
|
| + for (var key in node1.attributes.keys) {
|
| + if (node1.attributes[key] != node2.attributes[key]) {
|
| + return false;
|
| + }
|
| + }
|
| + }
|
| + return true;
|
| + }
|
| +
|
| + // helper
|
| + void addFormattingElement(token) {
|
| + tree.insertElement(token);
|
| + var element = tree.openElements.last;
|
| +
|
| + var matchingElements = [];
|
| + for (Node node in tree.activeFormattingElements.reversed) {
|
| + if (node == Marker) {
|
| + break;
|
| + } else if (isMatchingFormattingElement(node, element)) {
|
| + matchingElements.add(node);
|
| + }
|
| + }
|
| +
|
| + assert(matchingElements.length <= 3);
|
| + if (matchingElements.length == 3) {
|
| + tree.activeFormattingElements.remove(matchingElements.last);
|
| + }
|
| + tree.activeFormattingElements.add(element);
|
| + }
|
| +
|
| + // the real deal
|
| + bool processEOF() {
|
| + for (Node node in tree.openElements.reversed) {
|
| + switch (node.tagName) {
|
| + case "dd": case "dt": case "li": case "p": case "tbody": case "td":
|
| + case "tfoot": case "th": case "thead": case "tr": case "body":
|
| + case "html":
|
| + continue;
|
| + }
|
| + parser.parseError(node.sourceSpan, "expected-closing-tag-but-got-eof");
|
| + break;
|
| + }
|
| + //Stop parsing
|
| + return false;
|
| + }
|
| +
|
| + void processSpaceCharactersDropNewline(StringToken token) {
|
| + // Sometimes (start of <pre>, <listing>, and <textarea> blocks) we
|
| + // want to drop leading newlines
|
| + var data = token.data;
|
| + dropNewline = false;
|
| + if (data.startsWith("\n")) {
|
| + var lastOpen = tree.openElements.last;
|
| + if (const ["pre", "listing", "textarea"].contains(lastOpen.tagName)
|
| + && !lastOpen.hasContent()) {
|
| + data = data.substring(1);
|
| + }
|
| + }
|
| + if (data.length > 0) {
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertText(data, token.span);
|
| + }
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + if (token.data == "\u0000") {
|
| + //The tokenizer should always emit null on its own
|
| + return null;
|
| + }
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertText(token.data, token.span);
|
| + if (parser.framesetOK && !allWhitespace(token.data)) {
|
| + parser.framesetOK = false;
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + if (dropNewline) {
|
| + processSpaceCharactersDropNewline(token);
|
| + } else {
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertText(token.data, token.span);
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + Token startTagProcessInHead(StartTagToken token) {
|
| + return parser._inHeadPhase.processStartTag(token);
|
| + }
|
| +
|
| + void startTagBody(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag", {"name": "body"});
|
| + if (tree.openElements.length == 1
|
| + || tree.openElements[1].tagName != "body") {
|
| + assert(parser.innerHTMLMode);
|
| + } else {
|
| + parser.framesetOK = false;
|
| + token.data.forEach((attr, value) {
|
| + tree.openElements[1].attributes.putIfAbsent(attr, () => value);
|
| + });
|
| + }
|
| + }
|
| +
|
| + void startTagFrameset(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag", {"name": "frameset"});
|
| + if ((tree.openElements.length == 1 ||
|
| + tree.openElements[1].tagName != "body")) {
|
| + assert(parser.innerHTMLMode);
|
| + } else if (parser.framesetOK) {
|
| + if (tree.openElements[1].parent != null) {
|
| + tree.openElements[1].parent.nodes.remove(tree.openElements[1]);
|
| + }
|
| + while (tree.openElements.last.tagName != "html") {
|
| + tree.openElements.removeLast();
|
| + }
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inFramesetPhase;
|
| + }
|
| + }
|
| +
|
| + void startTagCloseP(StartTagToken token) {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + endTagP(new EndTagToken("p"));
|
| + }
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagPreListing(StartTagToken token) {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + endTagP(new EndTagToken("p"));
|
| + }
|
| + tree.insertElement(token);
|
| + parser.framesetOK = false;
|
| + dropNewline = true;
|
| + }
|
| +
|
| + void startTagForm(StartTagToken token) {
|
| + if (tree.formPointer != null) {
|
| + parser.parseError(token.span, "unexpected-start-tag", {"name": "form"});
|
| + } else {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + endTagP(new EndTagToken("p"));
|
| + }
|
| + tree.insertElement(token);
|
| + tree.formPointer = tree.openElements.last;
|
| + }
|
| + }
|
| +
|
| + void startTagListItem(StartTagToken token) {
|
| + parser.framesetOK = false;
|
| +
|
| + final stopNamesMap = const {"li": const ["li"],
|
| + "dt": const ["dt", "dd"],
|
| + "dd": const ["dt", "dd"]};
|
| + var stopNames = stopNamesMap[token.name];
|
| + for (Node node in tree.openElements.reversed) {
|
| + if (stopNames.contains(node.tagName)) {
|
| + parser.phase.processEndTag(new EndTagToken(node.tagName));
|
| + break;
|
| + }
|
| + if (specialElements.contains(node.nameTuple) &&
|
| + !const ["address", "div", "p"].contains(node.tagName)) {
|
| + break;
|
| + }
|
| + }
|
| +
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + parser.phase.processEndTag(new EndTagToken("p"));
|
| + }
|
| +
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagPlaintext(StartTagToken token) {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + endTagP(new EndTagToken("p"));
|
| + }
|
| + tree.insertElement(token);
|
| + parser.tokenizer.state = parser.tokenizer.plaintextState;
|
| + }
|
| +
|
| + void startTagHeading(StartTagToken token) {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + endTagP(new EndTagToken("p"));
|
| + }
|
| + if (headingElements.contains(tree.openElements.last.tagName)) {
|
| + parser.parseError(token.span, "unexpected-start-tag",
|
| + {"name": token.name});
|
| + tree.openElements.removeLast();
|
| + }
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagA(StartTagToken token) {
|
| + var afeAElement = tree.elementInActiveFormattingElements("a");
|
| + if (afeAElement != null) {
|
| + parser.parseError(token.span, "unexpected-start-tag-implies-end-tag",
|
| + {"startName": "a", "endName": "a"});
|
| + endTagFormatting(new EndTagToken("a"));
|
| + tree.openElements.remove(afeAElement);
|
| + tree.activeFormattingElements.remove(afeAElement);
|
| + }
|
| + tree.reconstructActiveFormattingElements();
|
| + addFormattingElement(token);
|
| + }
|
| +
|
| + void startTagFormatting(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + addFormattingElement(token);
|
| + }
|
| +
|
| + void startTagNobr(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + if (tree.elementInScope("nobr")) {
|
| + parser.parseError(token.span, "unexpected-start-tag-implies-end-tag",
|
| + {"startName": "nobr", "endName": "nobr"});
|
| + processEndTag(new EndTagToken("nobr"));
|
| + // XXX Need tests that trigger the following
|
| + tree.reconstructActiveFormattingElements();
|
| + }
|
| + addFormattingElement(token);
|
| + }
|
| +
|
| + Token startTagButton(StartTagToken token) {
|
| + if (tree.elementInScope("button")) {
|
| + parser.parseError(token.span, "unexpected-start-tag-implies-end-tag",
|
| + {"startName": "button", "endName": "button"});
|
| + processEndTag(new EndTagToken("button"));
|
| + return token;
|
| + } else {
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertElement(token);
|
| + parser.framesetOK = false;
|
| + }
|
| + }
|
| +
|
| + void startTagAppletMarqueeObject(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertElement(token);
|
| + tree.activeFormattingElements.add(Marker);
|
| + parser.framesetOK = false;
|
| + }
|
| +
|
| + void startTagXmp(StartTagToken token) {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + endTagP(new EndTagToken("p"));
|
| + }
|
| + tree.reconstructActiveFormattingElements();
|
| + parser.framesetOK = false;
|
| + parser.parseRCDataRawtext(token, "RAWTEXT");
|
| + }
|
| +
|
| + void startTagTable(StartTagToken token) {
|
| + if (parser.compatMode != "quirks") {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + processEndTag(new EndTagToken("p"));
|
| + }
|
| + }
|
| + tree.insertElement(token);
|
| + parser.framesetOK = false;
|
| + parser.phase = parser._inTablePhase;
|
| + }
|
| +
|
| + void startTagVoidFormatting(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertElement(token);
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| + parser.framesetOK = false;
|
| + }
|
| +
|
| + void startTagInput(StartTagToken token) {
|
| + var savedFramesetOK = parser.framesetOK;
|
| + startTagVoidFormatting(token);
|
| + if (asciiUpper2Lower(token.data["type"]) == "hidden") {
|
| + //input type=hidden doesn't change framesetOK
|
| + parser.framesetOK = savedFramesetOK;
|
| + }
|
| + }
|
| +
|
| + void startTagParamSource(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| + }
|
| +
|
| + void startTagHr(StartTagToken token) {
|
| + if (tree.elementInScope("p", variant: "button")) {
|
| + endTagP(new EndTagToken("p"));
|
| + }
|
| + tree.insertElement(token);
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| + parser.framesetOK = false;
|
| + }
|
| +
|
| + void startTagImage(StartTagToken token) {
|
| + // No really...
|
| + parser.parseError(token.span, "unexpected-start-tag-treated-as",
|
| + {"originalName": "image", "newName": "img"});
|
| + processStartTag(new StartTagToken("img", data: token.data,
|
| + selfClosing: token.selfClosing));
|
| + }
|
| +
|
| + void startTagIsIndex(StartTagToken token) {
|
| + parser.parseError(token.span, "deprecated-tag", {"name": "isindex"});
|
| + if (tree.formPointer != null) {
|
| + return;
|
| + }
|
| + var formAttrs = {};
|
| + var dataAction = token.data["action"];
|
| + if (dataAction != null) {
|
| + formAttrs["action"] = dataAction;
|
| + }
|
| + processStartTag(new StartTagToken("form", data: formAttrs));
|
| + processStartTag(new StartTagToken("hr", data: {}));
|
| + processStartTag(new StartTagToken("label", data: {}));
|
| + // XXX Localization ...
|
| + var prompt = token.data["prompt"];
|
| + if (prompt == null) {
|
| + prompt = "This is a searchable index. Enter search keywords: ";
|
| + }
|
| + processCharacters(new CharactersToken(prompt));
|
| + var attributes = new LinkedHashMap.from(token.data);
|
| + attributes.remove('action');
|
| + attributes.remove('prompt');
|
| + attributes["name"] = "isindex";
|
| + processStartTag(new StartTagToken("input",
|
| + data: attributes, selfClosing: token.selfClosing));
|
| + processEndTag(new EndTagToken("label"));
|
| + processStartTag(new StartTagToken("hr", data: {}));
|
| + processEndTag(new EndTagToken("form"));
|
| + }
|
| +
|
| + void startTagTextarea(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + parser.tokenizer.state = parser.tokenizer.rcdataState;
|
| + dropNewline = true;
|
| + parser.framesetOK = false;
|
| + }
|
| +
|
| + void startTagIFrame(StartTagToken token) {
|
| + parser.framesetOK = false;
|
| + startTagRawtext(token);
|
| + }
|
| +
|
| + /** iframe, noembed noframes, noscript(if scripting enabled). */
|
| + void startTagRawtext(StartTagToken token) {
|
| + parser.parseRCDataRawtext(token, "RAWTEXT");
|
| + }
|
| +
|
| + void startTagOpt(StartTagToken token) {
|
| + if (tree.openElements.last.tagName == "option") {
|
| + parser.phase.processEndTag(new EndTagToken("option"));
|
| + }
|
| + tree.reconstructActiveFormattingElements();
|
| + parser.tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagSelect(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertElement(token);
|
| + parser.framesetOK = false;
|
| +
|
| + if (parser._inTablePhase == parser.phase ||
|
| + parser._inCaptionPhase == parser.phase ||
|
| + parser._inColumnGroupPhase == parser.phase ||
|
| + parser._inTableBodyPhase == parser.phase ||
|
| + parser._inRowPhase == parser.phase ||
|
| + parser._inCellPhase == parser.phase) {
|
| + parser.phase = parser._inSelectInTablePhase;
|
| + } else {
|
| + parser.phase = parser._inSelectPhase;
|
| + }
|
| + }
|
| +
|
| + void startTagRpRt(StartTagToken token) {
|
| + if (tree.elementInScope("ruby")) {
|
| + tree.generateImpliedEndTags();
|
| + var last = tree.openElements.last;
|
| + if (last.tagName != "ruby") {
|
| + parser.parseError(last.sourceSpan, 'undefined-error');
|
| + }
|
| + }
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagMath(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + parser.adjustMathMLAttributes(token);
|
| + parser.adjustForeignAttributes(token);
|
| + token.namespace = Namespaces.mathml;
|
| + tree.insertElement(token);
|
| + //Need to get the parse error right for the case where the token
|
| + //has a namespace not equal to the xmlns attribute
|
| + if (token.selfClosing) {
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| + }
|
| + }
|
| +
|
| + void startTagSvg(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + parser.adjustSVGAttributes(token);
|
| + parser.adjustForeignAttributes(token);
|
| + token.namespace = Namespaces.svg;
|
| + tree.insertElement(token);
|
| + //Need to get the parse error right for the case where the token
|
| + //has a namespace not equal to the xmlns attribute
|
| + if (token.selfClosing) {
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * Elements that should be children of other elements that have a
|
| + * different insertion mode; here they are ignored
|
| + * "caption", "col", "colgroup", "frame", "frameset", "head",
|
| + * "option", "optgroup", "tbody", "td", "tfoot", "th", "thead",
|
| + * "tr", "noscript"
|
| + */
|
| + void startTagMisplaced(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-ignored",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void endTagP(EndTagToken token) {
|
| + if (!tree.elementInScope("p", variant: "button")) {
|
| + startTagCloseP(new StartTagToken("p", data: {}));
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": "p"});
|
| + endTagP(new EndTagToken("p"));
|
| + } else {
|
| + tree.generateImpliedEndTags("p");
|
| + if (tree.openElements.last.tagName != "p") {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": "p"});
|
| + }
|
| + popOpenElementsUntil("p");
|
| + }
|
| + }
|
| +
|
| + void endTagBody(EndTagToken token) {
|
| + if (!tree.elementInScope("body")) {
|
| + parser.parseError(token.span, 'undefined-error');
|
| + return;
|
| + } else if (tree.openElements.last.tagName != "body") {
|
| + for (Node node in slice(tree.openElements, 2)) {
|
| + switch (node.tagName) {
|
| + case "dd": case "dt": case "li": case "optgroup": case "option":
|
| + case "p": case "rp": case "rt": case "tbody": case "td": case "tfoot":
|
| + case "th": case "thead": case "tr": case "body": case "html":
|
| + continue;
|
| + }
|
| + // Not sure this is the correct name for the parse error
|
| + parser.parseError(token.span, "expected-one-end-tag-but-got-another",
|
| + {"expectedName": "body", "gotName": node.tagName});
|
| + break;
|
| + }
|
| + }
|
| + parser.phase = parser._afterBodyPhase;
|
| + }
|
| +
|
| + Token endTagHtml(EndTagToken token) {
|
| + //We repeat the test for the body end tag token being ignored here
|
| + if (tree.elementInScope("body")) {
|
| + endTagBody(new EndTagToken("body"));
|
| + return token;
|
| + }
|
| + }
|
| +
|
| + void endTagBlock(EndTagToken token) {
|
| + //Put us back in the right whitespace handling mode
|
| + if (token.name == "pre") {
|
| + dropNewline = false;
|
| + }
|
| + var inScope = tree.elementInScope(token.name);
|
| + if (inScope) {
|
| + tree.generateImpliedEndTags();
|
| + }
|
| + if (tree.openElements.last.tagName != token.name) {
|
| + parser.parseError(token.span, "end-tag-too-early", {"name": token.name});
|
| + }
|
| + if (inScope) {
|
| + popOpenElementsUntil(token.name);
|
| + }
|
| + }
|
| +
|
| + void endTagForm(EndTagToken token) {
|
| + var node = tree.formPointer;
|
| + tree.formPointer = null;
|
| + if (node == null || !tree.elementInScope(node)) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": "form"});
|
| + } else {
|
| + tree.generateImpliedEndTags();
|
| + if (tree.openElements.last != node) {
|
| + parser.parseError(token.span, "end-tag-too-early-ignored", {"name": "form"});
|
| + }
|
| + tree.openElements.remove(node);
|
| + }
|
| + }
|
| +
|
| + void endTagListItem(EndTagToken token) {
|
| + var variant;
|
| + if (token.name == "li") {
|
| + variant = "list";
|
| + } else {
|
| + variant = null;
|
| + }
|
| + if (!tree.elementInScope(token.name, variant: variant)) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + } else {
|
| + tree.generateImpliedEndTags(token.name);
|
| + if (tree.openElements.last.tagName != token.name) {
|
| + parser.parseError(token.span, "end-tag-too-early", {"name": token.name});
|
| + }
|
| + popOpenElementsUntil(token.name);
|
| + }
|
| + }
|
| +
|
| + void endTagHeading(EndTagToken token) {
|
| + for (var item in headingElements) {
|
| + if (tree.elementInScope(item)) {
|
| + tree.generateImpliedEndTags();
|
| + break;
|
| + }
|
| + }
|
| + if (tree.openElements.last.tagName != token.name) {
|
| + parser.parseError(token.span, "end-tag-too-early", {"name": token.name});
|
| + }
|
| +
|
| + for (var item in headingElements) {
|
| + if (tree.elementInScope(item)) {
|
| + item = tree.openElements.removeLast();
|
| + while (!headingElements.contains(item.tagName)) {
|
| + item = tree.openElements.removeLast();
|
| + }
|
| + break;
|
| + }
|
| + }
|
| + }
|
| +
|
| + /** The much-feared adoption agency algorithm. */
|
| + endTagFormatting(EndTagToken token) {
|
| + // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency
|
| + // TODO(jmesserly): the comments here don't match the numbered steps in the
|
| + // updated spec. This needs a pass over it to verify that it still matches.
|
| + // In particular the html5lib Python code skiped "step 4", I'm not sure why.
|
| + // XXX Better parseError messages appreciated.
|
| + int outerLoopCounter = 0;
|
| + while (outerLoopCounter < 8) {
|
| + outerLoopCounter += 1;
|
| +
|
| + // Step 1 paragraph 1
|
| + var formattingElement = tree.elementInActiveFormattingElements(
|
| + token.name);
|
| + if (formattingElement == null ||
|
| + (tree.openElements.contains(formattingElement) &&
|
| + !tree.elementInScope(formattingElement.tagName))) {
|
| + parser.parseError(token.span, "adoption-agency-1.1",
|
| + {"name": token.name});
|
| + return;
|
| + // Step 1 paragraph 2
|
| + } else if (!tree.openElements.contains(formattingElement)) {
|
| + parser.parseError(token.span, "adoption-agency-1.2",
|
| + {"name": token.name});
|
| + tree.activeFormattingElements.remove(formattingElement);
|
| + return;
|
| + }
|
| +
|
| + // Step 1 paragraph 3
|
| + if (formattingElement != tree.openElements.last) {
|
| + parser.parseError(token.span, "adoption-agency-1.3",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + // Step 2
|
| + // Start of the adoption agency algorithm proper
|
| + var afeIndex = tree.openElements.indexOf(formattingElement);
|
| + Node furthestBlock = null;
|
| + for (Node element in slice(tree.openElements, afeIndex)) {
|
| + if (specialElements.contains(element.nameTuple)) {
|
| + furthestBlock = element;
|
| + break;
|
| + }
|
| + }
|
| + // Step 3
|
| + if (furthestBlock == null) {
|
| + var element = tree.openElements.removeLast();
|
| + while (element != formattingElement) {
|
| + element = tree.openElements.removeLast();
|
| + }
|
| + tree.activeFormattingElements.remove(element);
|
| + return;
|
| + }
|
| +
|
| + var commonAncestor = tree.openElements[afeIndex - 1];
|
| +
|
| + // Step 5
|
| + // The bookmark is supposed to help us identify where to reinsert
|
| + // nodes in step 12. We have to ensure that we reinsert nodes after
|
| + // the node before the active formatting element. Note the bookmark
|
| + // can move in step 7.4
|
| + var bookmark = tree.activeFormattingElements.indexOf(formattingElement);
|
| +
|
| + // Step 6
|
| + Node lastNode = furthestBlock;
|
| + var node = furthestBlock;
|
| + int innerLoopCounter = 0;
|
| +
|
| + var index = tree.openElements.indexOf(node);
|
| + while (innerLoopCounter < 3) {
|
| + innerLoopCounter += 1;
|
| +
|
| + // Node is element before node in open elements
|
| + index -= 1;
|
| + node = tree.openElements[index];
|
| + if (!tree.activeFormattingElements.contains(node)) {
|
| + tree.openElements.remove(node);
|
| + continue;
|
| + }
|
| + // Step 6.3
|
| + if (node == formattingElement) {
|
| + break;
|
| + }
|
| + // Step 6.4
|
| + if (lastNode == furthestBlock) {
|
| + bookmark = (tree.activeFormattingElements.indexOf(node) + 1);
|
| + }
|
| + // Step 6.5
|
| + //cite = node.parent
|
| + var clone = node.clone();
|
| + // Replace node with clone
|
| + tree.activeFormattingElements[
|
| + tree.activeFormattingElements.indexOf(node)] = clone;
|
| + tree.openElements[tree.openElements.indexOf(node)] = clone;
|
| + node = clone;
|
| +
|
| + // Step 6.6
|
| + // Remove lastNode from its parents, if any
|
| + if (lastNode.parent != null) {
|
| + lastNode.parent.nodes.remove(lastNode);
|
| + }
|
| + node.nodes.add(lastNode);
|
| + // Step 7.7
|
| + lastNode = node;
|
| + // End of inner loop
|
| + }
|
| +
|
| + // Step 7
|
| + // Foster parent lastNode if commonAncestor is a
|
| + // table, tbody, tfoot, thead, or tr we need to foster parent the
|
| + // lastNode
|
| + if (lastNode.parent != null) {
|
| + lastNode.parent.nodes.remove(lastNode);
|
| + }
|
| +
|
| + if (const ["table", "tbody", "tfoot", "thead", "tr"].contains(
|
| + commonAncestor.tagName)) {
|
| + var nodePos = tree.getTableMisnestedNodePosition();
|
| + nodePos[0].insertBefore(lastNode, nodePos[1]);
|
| + } else {
|
| + commonAncestor.nodes.add(lastNode);
|
| + }
|
| +
|
| + // Step 8
|
| + var clone = formattingElement.clone();
|
| +
|
| + // Step 9
|
| + furthestBlock.reparentChildren(clone);
|
| +
|
| + // Step 10
|
| + furthestBlock.nodes.add(clone);
|
| +
|
| + // Step 11
|
| + tree.activeFormattingElements.remove(formattingElement);
|
| + tree.activeFormattingElements.insert(
|
| + min(bookmark, tree.activeFormattingElements.length), clone);
|
| +
|
| + // Step 12
|
| + tree.openElements.remove(formattingElement);
|
| + tree.openElements.insert(
|
| + tree.openElements.indexOf(furthestBlock) + 1, clone);
|
| + }
|
| + }
|
| +
|
| + void endTagAppletMarqueeObject(EndTagToken token) {
|
| + if (tree.elementInScope(token.name)) {
|
| + tree.generateImpliedEndTags();
|
| + }
|
| + if (tree.openElements.last.tagName != token.name) {
|
| + parser.parseError(token.span, "end-tag-too-early", {"name": token.name});
|
| + }
|
| + if (tree.elementInScope(token.name)) {
|
| + popOpenElementsUntil(token.name);
|
| + tree.clearActiveFormattingElements();
|
| + }
|
| + }
|
| +
|
| + void endTagBr(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-treated-as",
|
| + {"originalName": "br", "newName": "br element"});
|
| + tree.reconstructActiveFormattingElements();
|
| + tree.insertElement(new StartTagToken("br", data: {}));
|
| + tree.openElements.removeLast();
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + for (Node node in tree.openElements.reversed) {
|
| + if (node.tagName == token.name) {
|
| + tree.generateImpliedEndTags(token.name);
|
| + if (tree.openElements.last.tagName != token.name) {
|
| + parser.parseError(token.span, "unexpected-end-tag",
|
| + {"name": token.name});
|
| + }
|
| + while (tree.openElements.removeLast() != node);
|
| + break;
|
| + } else {
|
| + if (specialElements.contains(node.nameTuple)) {
|
| + parser.parseError(token.span, "unexpected-end-tag",
|
| + {"name": token.name});
|
| + break;
|
| + }
|
| + }
|
| + }
|
| + }
|
| +}
|
| +
|
| +
|
| +class TextPhase extends Phase {
|
| + TextPhase(parser) : super(parser);
|
| +
|
| + // "Tried to process start tag %s in RCDATA/RAWTEXT mode"%token.name
|
| + processStartTag(StartTagToken token) { assert(false); }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + if (token.name == 'script') return endTagScript(token);
|
| + return endTagOther(token);
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + tree.insertText(token.data, token.span);
|
| + }
|
| +
|
| + bool processEOF() {
|
| + var last = tree.openElements.last;
|
| + parser.parseError(last.sourceSpan, "expected-named-closing-tag-but-got-eof",
|
| + {'name': last.tagName});
|
| + tree.openElements.removeLast();
|
| + parser.phase = parser.originalPhase;
|
| + return true;
|
| + }
|
| +
|
| + void endTagScript(EndTagToken token) {
|
| + var node = tree.openElements.removeLast();
|
| + assert(node.tagName == "script");
|
| + parser.phase = parser.originalPhase;
|
| + //The rest of this method is all stuff that only happens if
|
| + //document.write works
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + var node = tree.openElements.removeLast();
|
| + parser.phase = parser.originalPhase;
|
| + }
|
| +}
|
| +
|
| +class InTablePhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-table
|
| + InTablePhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "caption": return startTagCaption(token);
|
| + case "colgroup": return startTagColgroup(token);
|
| + case "col": return startTagCol(token);
|
| + case "tbody": case "tfoot": case "thead": return startTagRowGroup(token);
|
| + case "td": case "th": case "tr": return startTagImplyTbody(token);
|
| + case "table": return startTagTable(token);
|
| + case "style": case "script": return startTagStyleScript(token);
|
| + case "input": return startTagInput(token);
|
| + case "form": return startTagForm(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "table": return endTagTable(token);
|
| + case "body": case "caption": case "col": case "colgroup": case "html":
|
| + case "tbody": case "td": case "tfoot": case "th": case "thead": case "tr":
|
| + return endTagIgnore(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + // helper methods
|
| + void clearStackToTableContext() {
|
| + // "clear the stack back to a table context"
|
| + while (tree.openElements.last.tagName != "table" &&
|
| + tree.openElements.last.tagName != "html") {
|
| + //parser.parseError(token.span, "unexpected-implied-end-tag-in-table",
|
| + // {"name": tree.openElements.last.name})
|
| + tree.openElements.removeLast();
|
| + }
|
| + // When the current node is <html> it's an innerHTML case
|
| + }
|
| +
|
| + // processing methods
|
| + bool processEOF() {
|
| + var last = tree.openElements.last;
|
| + if (last.tagName != "html") {
|
| + parser.parseError(last.sourceSpan, "eof-in-table");
|
| + } else {
|
| + assert(parser.innerHTMLMode);
|
| + }
|
| + //Stop parsing
|
| + return false;
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + var originalPhase = parser.phase;
|
| + parser.phase = parser._inTableTextPhase;
|
| + parser._inTableTextPhase.originalPhase = originalPhase;
|
| + parser.phase.processSpaceCharacters(token);
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + var originalPhase = parser.phase;
|
| + parser.phase = parser._inTableTextPhase;
|
| + parser._inTableTextPhase.originalPhase = originalPhase;
|
| + parser.phase.processCharacters(token);
|
| + }
|
| +
|
| + void insertText(CharactersToken token) {
|
| + // If we get here there must be at least one non-whitespace character
|
| + // Do the table magic!
|
| + tree.insertFromTable = true;
|
| + parser._inBodyPhase.processCharacters(token);
|
| + tree.insertFromTable = false;
|
| + }
|
| +
|
| + void startTagCaption(StartTagToken token) {
|
| + clearStackToTableContext();
|
| + tree.activeFormattingElements.add(Marker);
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inCaptionPhase;
|
| + }
|
| +
|
| + void startTagColgroup(StartTagToken token) {
|
| + clearStackToTableContext();
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inColumnGroupPhase;
|
| + }
|
| +
|
| + Token startTagCol(StartTagToken token) {
|
| + startTagColgroup(new StartTagToken("colgroup", data: {}));
|
| + return token;
|
| + }
|
| +
|
| + void startTagRowGroup(StartTagToken token) {
|
| + clearStackToTableContext();
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inTableBodyPhase;
|
| + }
|
| +
|
| + Token startTagImplyTbody(StartTagToken token) {
|
| + startTagRowGroup(new StartTagToken("tbody", data: {}));
|
| + return token;
|
| + }
|
| +
|
| + Token startTagTable(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-implies-end-tag",
|
| + {"startName": "table", "endName": "table"});
|
| + parser.phase.processEndTag(new EndTagToken("table"));
|
| + if (!parser.innerHTMLMode) {
|
| + return token;
|
| + }
|
| + }
|
| +
|
| + Token startTagStyleScript(StartTagToken token) {
|
| + return parser._inHeadPhase.processStartTag(token);
|
| + }
|
| +
|
| + void startTagInput(StartTagToken token) {
|
| + if (asciiUpper2Lower(token.data["type"]) == "hidden") {
|
| + parser.parseError(token.span, "unexpected-hidden-input-in-table");
|
| + tree.insertElement(token);
|
| + // XXX associate with form
|
| + tree.openElements.removeLast();
|
| + } else {
|
| + startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + void startTagForm(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-form-in-table");
|
| + if (tree.formPointer == null) {
|
| + tree.insertElement(token);
|
| + tree.formPointer = tree.openElements.last;
|
| + tree.openElements.removeLast();
|
| + }
|
| + }
|
| +
|
| + void startTagOther(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-implies-table-voodoo",
|
| + {"name": token.name});
|
| + // Do the table magic!
|
| + tree.insertFromTable = true;
|
| + parser._inBodyPhase.processStartTag(token);
|
| + tree.insertFromTable = false;
|
| + }
|
| +
|
| + void endTagTable(EndTagToken token) {
|
| + if (tree.elementInScope("table", variant: "table")) {
|
| + tree.generateImpliedEndTags();
|
| + var last = tree.openElements.last;
|
| + if (last.tagName != "table") {
|
| + parser.parseError(token.span, "end-tag-too-early-named",
|
| + {"gotName": "table", "expectedName": last.tagName});
|
| + }
|
| + while (tree.openElements.last.tagName != "table") {
|
| + tree.openElements.removeLast();
|
| + }
|
| + tree.openElements.removeLast();
|
| + parser.resetInsertionMode();
|
| + } else {
|
| + // innerHTML case
|
| + assert(parser.innerHTMLMode);
|
| + parser.parseError(token.span, "undefined-error");
|
| + }
|
| + }
|
| +
|
| + void endTagIgnore(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-implies-table-voodoo",
|
| + {"name": token.name});
|
| + // Do the table magic!
|
| + tree.insertFromTable = true;
|
| + parser._inBodyPhase.processEndTag(token);
|
| + tree.insertFromTable = false;
|
| + }
|
| +}
|
| +
|
| +class InTableTextPhase extends Phase {
|
| + Phase originalPhase;
|
| + List<StringToken> characterTokens;
|
| +
|
| + InTableTextPhase(parser)
|
| + : characterTokens = <StringToken>[],
|
| + super(parser);
|
| +
|
| + void flushCharacters() {
|
| + if (characterTokens.length == 0) return;
|
| +
|
| + // TODO(sigmund,jmesserly): remove '' (dartbug.com/8480)
|
| + var data = characterTokens.map((t) => t.data).join('');
|
| + var span = null;
|
| +
|
| + if (parser.generateSpans) {
|
| + span = new FileSpan.union(
|
| + characterTokens[0].span,
|
| + characterTokens.last.span);
|
| + }
|
| +
|
| + if (!allWhitespace(data)) {
|
| + parser._inTablePhase.insertText(new CharactersToken(data)..span = span);
|
| + } else if (data.length > 0) {
|
| + tree.insertText(data, span);
|
| + }
|
| + characterTokens = <StringToken>[];
|
| + }
|
| +
|
| + Token processComment(CommentToken token) {
|
| + flushCharacters();
|
| + parser.phase = originalPhase;
|
| + return token;
|
| + }
|
| +
|
| + bool processEOF() {
|
| + flushCharacters();
|
| + parser.phase = originalPhase;
|
| + return true;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + if (token.data == "\u0000") {
|
| + return null;
|
| + }
|
| + characterTokens.add(token);
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + //pretty sure we should never reach here
|
| + characterTokens.add(token);
|
| + // XXX assert(false);
|
| + }
|
| +
|
| + Token processStartTag(StartTagToken token) {
|
| + flushCharacters();
|
| + parser.phase = originalPhase;
|
| + return token;
|
| + }
|
| +
|
| + Token processEndTag(EndTagToken token) {
|
| + flushCharacters();
|
| + parser.phase = originalPhase;
|
| + return token;
|
| + }
|
| +}
|
| +
|
| +
|
| +class InCaptionPhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-caption
|
| + InCaptionPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "caption": case "col": case "colgroup": case "tbody": case "td":
|
| + case "tfoot": case "th": case "thead": case "tr":
|
| + return startTagTableElement(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "caption": return endTagCaption(token);
|
| + case "table": return endTagTable(token);
|
| + case "body": case "col": case "colgroup": case "html": case "tbody":
|
| + case "td": case "tfoot": case "th": case "thead": case "tr":
|
| + return endTagIgnore(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool ignoreEndTagCaption() {
|
| + return !tree.elementInScope("caption", variant: "table");
|
| + }
|
| +
|
| + bool processEOF() {
|
| + parser._inBodyPhase.processEOF();
|
| + return false;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + return parser._inBodyPhase.processCharacters(token);
|
| + }
|
| +
|
| + Token startTagTableElement(StartTagToken token) {
|
| + parser.parseError(token.span, "undefined-error");
|
| + //XXX Have to duplicate logic here to find out if the tag is ignored
|
| + var ignoreEndTag = ignoreEndTagCaption();
|
| + parser.phase.processEndTag(new EndTagToken("caption"));
|
| + if (!ignoreEndTag) {
|
| + return token;
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + void endTagCaption(EndTagToken token) {
|
| + if (!ignoreEndTagCaption()) {
|
| + // AT this code is quite similar to endTagTable in "InTable"
|
| + tree.generateImpliedEndTags();
|
| + if (tree.openElements.last.tagName != "caption") {
|
| + parser.parseError(token.span, "expected-one-end-tag-but-got-another",
|
| + {"gotName": "caption",
|
| + "expectedName": tree.openElements.last.tagName});
|
| + }
|
| + while (tree.openElements.last.tagName != "caption") {
|
| + tree.openElements.removeLast();
|
| + }
|
| + tree.openElements.removeLast();
|
| + tree.clearActiveFormattingElements();
|
| + parser.phase = parser._inTablePhase;
|
| + } else {
|
| + // innerHTML case
|
| + assert(parser.innerHTMLMode);
|
| + parser.parseError(token.span, "undefined-error");
|
| + }
|
| + }
|
| +
|
| + Token endTagTable(EndTagToken token) {
|
| + parser.parseError(token.span, "undefined-error");
|
| + var ignoreEndTag = ignoreEndTagCaption();
|
| + parser.phase.processEndTag(new EndTagToken("caption"));
|
| + if (!ignoreEndTag) {
|
| + return token;
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + void endTagIgnore(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + }
|
| +
|
| + Token endTagOther(EndTagToken token) {
|
| + return parser._inBodyPhase.processEndTag(token);
|
| + }
|
| +}
|
| +
|
| +
|
| +class InColumnGroupPhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-column
|
| + InColumnGroupPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "col": return startTagCol(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "colgroup": return endTagColgroup(token);
|
| + case "col": return endTagCol(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool ignoreEndTagColgroup() {
|
| + return tree.openElements.last.tagName == "html";
|
| + }
|
| +
|
| + bool processEOF() {
|
| + var ignoreEndTag = ignoreEndTagColgroup();
|
| + if (ignoreEndTag) {
|
| + assert(parser.innerHTMLMode);
|
| + return false;
|
| + } else {
|
| + endTagColgroup(new EndTagToken("colgroup"));
|
| + return true;
|
| + }
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + var ignoreEndTag = ignoreEndTagColgroup();
|
| + endTagColgroup(new EndTagToken("colgroup"));
|
| + return ignoreEndTag ? null : token;
|
| + }
|
| +
|
| + void startTagCol(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + tree.openElements.removeLast();
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + var ignoreEndTag = ignoreEndTagColgroup();
|
| + endTagColgroup(new EndTagToken("colgroup"));
|
| + return ignoreEndTag ? null : token;
|
| + }
|
| +
|
| + void endTagColgroup(EndTagToken token) {
|
| + if (ignoreEndTagColgroup()) {
|
| + // innerHTML case
|
| + assert(parser.innerHTMLMode);
|
| + parser.parseError(token.span, "undefined-error");
|
| + } else {
|
| + tree.openElements.removeLast();
|
| + parser.phase = parser._inTablePhase;
|
| + }
|
| + }
|
| +
|
| + void endTagCol(EndTagToken token) {
|
| + parser.parseError(token.span, "no-end-tag", {"name": "col"});
|
| + }
|
| +
|
| + Token endTagOther(EndTagToken token) {
|
| + var ignoreEndTag = ignoreEndTagColgroup();
|
| + endTagColgroup(new EndTagToken("colgroup"));
|
| + return ignoreEndTag ? null : token;
|
| + }
|
| +}
|
| +
|
| +
|
| +class InTableBodyPhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-table0
|
| + InTableBodyPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "tr": return startTagTr(token);
|
| + case "td": case "th": return startTagTableCell(token);
|
| + case "caption": case "col": case "colgroup": case "tbody": case "tfoot":
|
| + case "thead":
|
| + return startTagTableOther(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "tbody": case "tfoot": case "thead":
|
| + return endTagTableRowGroup(token);
|
| + case "table": return endTagTable(token);
|
| + case "body": case "caption": case "col": case "colgroup": case "html":
|
| + case "td": case "th": case "tr":
|
| + return endTagIgnore(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + // helper methods
|
| + void clearStackToTableBodyContext() {
|
| + var tableTags = const ["tbody", "tfoot", "thead", "html"];
|
| + while (!tableTags.contains(tree.openElements.last.tagName)) {
|
| + //XXX parser.parseError(token.span, "unexpected-implied-end-tag-in-table",
|
| + // {"name": tree.openElements.last.name})
|
| + tree.openElements.removeLast();
|
| + }
|
| + if (tree.openElements.last.tagName == "html") {
|
| + assert(parser.innerHTMLMode);
|
| + }
|
| + }
|
| +
|
| + // the rest
|
| + bool processEOF() {
|
| + parser._inTablePhase.processEOF();
|
| + return false;
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + return parser._inTablePhase.processSpaceCharacters(token);
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + return parser._inTablePhase.processCharacters(token);
|
| + }
|
| +
|
| + void startTagTr(StartTagToken token) {
|
| + clearStackToTableBodyContext();
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inRowPhase;
|
| + }
|
| +
|
| + Token startTagTableCell(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-cell-in-table-body",
|
| + {"name": token.name});
|
| + startTagTr(new StartTagToken("tr", data: {}));
|
| + return token;
|
| + }
|
| +
|
| + Token startTagTableOther(token) => endTagTable(token);
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + return parser._inTablePhase.processStartTag(token);
|
| + }
|
| +
|
| + void endTagTableRowGroup(EndTagToken token) {
|
| + if (tree.elementInScope(token.name, variant: "table")) {
|
| + clearStackToTableBodyContext();
|
| + tree.openElements.removeLast();
|
| + parser.phase = parser._inTablePhase;
|
| + } else {
|
| + parser.parseError(token.span, "unexpected-end-tag-in-table-body",
|
| + {"name": token.name});
|
| + }
|
| + }
|
| +
|
| + Token endTagTable(TagToken token) {
|
| + // XXX AT Any ideas on how to share this with endTagTable?
|
| + if (tree.elementInScope("tbody", variant: "table") ||
|
| + tree.elementInScope("thead", variant: "table") ||
|
| + tree.elementInScope("tfoot", variant: "table")) {
|
| + clearStackToTableBodyContext();
|
| + endTagTableRowGroup(new EndTagToken(tree.openElements.last.tagName));
|
| + return token;
|
| + } else {
|
| + // innerHTML case
|
| + assert(parser.innerHTMLMode);
|
| + parser.parseError(token.span, "undefined-error");
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + void endTagIgnore(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-in-table-body",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + Token endTagOther(EndTagToken token) {
|
| + return parser._inTablePhase.processEndTag(token);
|
| + }
|
| +}
|
| +
|
| +
|
| +class InRowPhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-row
|
| + InRowPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "td": case "th": return startTagTableCell(token);
|
| + case "caption": case "col": case "colgroup": case "tbody": case "tfoot":
|
| + case "thead": case "tr":
|
| + return startTagTableOther(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "tr": return endTagTr(token);
|
| + case "table": return endTagTable(token);
|
| + case "tbody": case "tfoot": case "thead":
|
| + return endTagTableRowGroup(token);
|
| + case "body": case "caption": case "col": case "colgroup": case "html":
|
| + case "td": case "th":
|
| + return endTagIgnore(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + // helper methods (XXX unify this with other table helper methods)
|
| + void clearStackToTableRowContext() {
|
| + while (true) {
|
| + var last = tree.openElements.last;
|
| + if (last.tagName == "tr" || last.tagName == "html") break;
|
| +
|
| + parser.parseError(last.sourceSpan,
|
| + "unexpected-implied-end-tag-in-table-row",
|
| + {"name": tree.openElements.last.tagName});
|
| + tree.openElements.removeLast();
|
| + }
|
| + }
|
| +
|
| + bool ignoreEndTagTr() {
|
| + return !tree.elementInScope("tr", variant: "table");
|
| + }
|
| +
|
| + // the rest
|
| + bool processEOF() {
|
| + parser._inTablePhase.processEOF();
|
| + return false;
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + return parser._inTablePhase.processSpaceCharacters(token);
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + return parser._inTablePhase.processCharacters(token);
|
| + }
|
| +
|
| + void startTagTableCell(StartTagToken token) {
|
| + clearStackToTableRowContext();
|
| + tree.insertElement(token);
|
| + parser.phase = parser._inCellPhase;
|
| + tree.activeFormattingElements.add(Marker);
|
| + }
|
| +
|
| + Token startTagTableOther(StartTagToken token) {
|
| + bool ignoreEndTag = ignoreEndTagTr();
|
| + endTagTr(new EndTagToken("tr"));
|
| + // XXX how are we sure it's always ignored in the innerHTML case?
|
| + return ignoreEndTag ? null : token;
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + return parser._inTablePhase.processStartTag(token);
|
| + }
|
| +
|
| + void endTagTr(EndTagToken token) {
|
| + if (!ignoreEndTagTr()) {
|
| + clearStackToTableRowContext();
|
| + tree.openElements.removeLast();
|
| + parser.phase = parser._inTableBodyPhase;
|
| + } else {
|
| + // innerHTML case
|
| + assert(parser.innerHTMLMode);
|
| + parser.parseError(token.span, "undefined-error");
|
| + }
|
| + }
|
| +
|
| + Token endTagTable(EndTagToken token) {
|
| + var ignoreEndTag = ignoreEndTagTr();
|
| + endTagTr(new EndTagToken("tr"));
|
| + // Reprocess the current tag if the tr end tag was not ignored
|
| + // XXX how are we sure it's always ignored in the innerHTML case?
|
| + return ignoreEndTag ? null : token;
|
| + }
|
| +
|
| + Token endTagTableRowGroup(EndTagToken token) {
|
| + if (tree.elementInScope(token.name, variant: "table")) {
|
| + endTagTr(new EndTagToken("tr"));
|
| + return token;
|
| + } else {
|
| + parser.parseError(token.span, "undefined-error");
|
| + return null;
|
| + }
|
| + }
|
| +
|
| + void endTagIgnore(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-in-table-row",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + Token endTagOther(EndTagToken token) {
|
| + return parser._inTablePhase.processEndTag(token);
|
| + }
|
| +}
|
| +
|
| +class InCellPhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-cell
|
| + InCellPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "caption": case "col": case "colgroup": case "tbody": case "td":
|
| + case "tfoot": case "th": case "thead": case "tr":
|
| + return startTagTableOther(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "td": case "th":
|
| + return endTagTableCell(token);
|
| + case "body": case "caption": case "col": case "colgroup": case "html":
|
| + return endTagIgnore(token);
|
| + case "table": case "tbody": case "tfoot": case "thead": case "tr":
|
| + return endTagImply(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + // helper
|
| + void closeCell() {
|
| + if (tree.elementInScope("td", variant: "table")) {
|
| + endTagTableCell(new EndTagToken("td"));
|
| + } else if (tree.elementInScope("th", variant: "table")) {
|
| + endTagTableCell(new EndTagToken("th"));
|
| + }
|
| + }
|
| +
|
| + // the rest
|
| + bool processEOF() {
|
| + parser._inBodyPhase.processEOF();
|
| + return false;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + return parser._inBodyPhase.processCharacters(token);
|
| + }
|
| +
|
| + Token startTagTableOther(StartTagToken token) {
|
| + if (tree.elementInScope("td", variant: "table") ||
|
| + tree.elementInScope("th", variant: "table")) {
|
| + closeCell();
|
| + return token;
|
| + } else {
|
| + // innerHTML case
|
| + assert(parser.innerHTMLMode);
|
| + parser.parseError(token.span, "undefined-error");
|
| + }
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + void endTagTableCell(EndTagToken token) {
|
| + if (tree.elementInScope(token.name, variant: "table")) {
|
| + tree.generateImpliedEndTags(token.name);
|
| + if (tree.openElements.last.tagName != token.name) {
|
| + parser.parseError(token.span, "unexpected-cell-end-tag",
|
| + {"name": token.name});
|
| + popOpenElementsUntil(token.name);
|
| + } else {
|
| + tree.openElements.removeLast();
|
| + }
|
| + tree.clearActiveFormattingElements();
|
| + parser.phase = parser._inRowPhase;
|
| + } else {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + }
|
| + }
|
| +
|
| + void endTagIgnore(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + }
|
| +
|
| + Token endTagImply(EndTagToken token) {
|
| + if (tree.elementInScope(token.name, variant: "table")) {
|
| + closeCell();
|
| + return token;
|
| + } else {
|
| + // sometimes innerHTML case
|
| + parser.parseError(token.span, "undefined-error");
|
| + }
|
| + }
|
| +
|
| + Token endTagOther(EndTagToken token) {
|
| + return parser._inBodyPhase.processEndTag(token);
|
| + }
|
| +}
|
| +
|
| +class InSelectPhase extends Phase {
|
| + InSelectPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "option": return startTagOption(token);
|
| + case "optgroup": return startTagOptgroup(token);
|
| + case "select": return startTagSelect(token);
|
| + case "input": case "keygen": case "textarea":
|
| + return startTagInput(token);
|
| + case "script": return startTagScript(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "option": return endTagOption(token);
|
| + case "optgroup": return endTagOptgroup(token);
|
| + case "select": return endTagSelect(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-select
|
| + bool processEOF() {
|
| + var last = tree.openElements.last;
|
| + if (last.tagName != "html") {
|
| + parser.parseError(last.sourceSpan, "eof-in-select");
|
| + } else {
|
| + assert(parser.innerHTMLMode);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + if (token.data == "\u0000") {
|
| + return null;
|
| + }
|
| + tree.insertText(token.data, token.span);
|
| + }
|
| +
|
| + void startTagOption(StartTagToken token) {
|
| + // We need to imply </option> if <option> is the current node.
|
| + if (tree.openElements.last.tagName == "option") {
|
| + tree.openElements.removeLast();
|
| + }
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagOptgroup(StartTagToken token) {
|
| + if (tree.openElements.last.tagName == "option") {
|
| + tree.openElements.removeLast();
|
| + }
|
| + if (tree.openElements.last.tagName == "optgroup") {
|
| + tree.openElements.removeLast();
|
| + }
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagSelect(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-select-in-select");
|
| + endTagSelect(new EndTagToken("select"));
|
| + }
|
| +
|
| + Token startTagInput(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-input-in-select");
|
| + if (tree.elementInScope("select", variant: "select")) {
|
| + endTagSelect(new EndTagToken("select"));
|
| + return token;
|
| + } else {
|
| + assert(parser.innerHTMLMode);
|
| + }
|
| + }
|
| +
|
| + Token startTagScript(StartTagToken token) {
|
| + return parser._inHeadPhase.processStartTag(token);
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-in-select",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + void endTagOption(EndTagToken token) {
|
| + if (tree.openElements.last.tagName == "option") {
|
| + tree.openElements.removeLast();
|
| + } else {
|
| + parser.parseError(token.span, "unexpected-end-tag-in-select",
|
| + {"name": "option"});
|
| + }
|
| + }
|
| +
|
| + void endTagOptgroup(EndTagToken token) {
|
| + // </optgroup> implicitly closes <option>
|
| + if (tree.openElements.last.tagName == "option" &&
|
| + tree.openElements[tree.openElements.length - 2].tagName == "optgroup") {
|
| + tree.openElements.removeLast();
|
| + }
|
| + // It also closes </optgroup>
|
| + if (tree.openElements.last.tagName == "optgroup") {
|
| + tree.openElements.removeLast();
|
| + // But nothing else
|
| + } else {
|
| + parser.parseError(token.span, "unexpected-end-tag-in-select",
|
| + {"name": "optgroup"});
|
| + }
|
| + }
|
| +
|
| + void endTagSelect(EndTagToken token) {
|
| + if (tree.elementInScope("select", variant: "select")) {
|
| + popOpenElementsUntil("select");
|
| + parser.resetInsertionMode();
|
| + } else {
|
| + // innerHTML case
|
| + assert(parser.innerHTMLMode);
|
| + parser.parseError(token.span, "undefined-error");
|
| + }
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-in-select",
|
| + {"name": token.name});
|
| + }
|
| +}
|
| +
|
| +
|
| +class InSelectInTablePhase extends Phase {
|
| + InSelectInTablePhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "caption": case "table": case "tbody": case "tfoot": case "thead":
|
| + case "tr": case "td": case "th":
|
| + return startTagTable(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "caption": case "table": case "tbody": case "tfoot": case "thead":
|
| + case "tr": case "td": case "th":
|
| + return endTagTable(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool processEOF() {
|
| + parser._inSelectPhase.processEOF();
|
| + return false;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + return parser._inSelectPhase.processCharacters(token);
|
| + }
|
| +
|
| + Token startTagTable(StartTagToken token) {
|
| + parser.parseError(token.span,
|
| + "unexpected-table-element-start-tag-in-select-in-table",
|
| + {"name": token.name});
|
| + endTagOther(new EndTagToken("select"));
|
| + return token;
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + return parser._inSelectPhase.processStartTag(token);
|
| + }
|
| +
|
| + Token endTagTable(EndTagToken token) {
|
| + parser.parseError(token.span,
|
| + "unexpected-table-element-end-tag-in-select-in-table",
|
| + {"name": token.name});
|
| + if (tree.elementInScope(token.name, variant: "table")) {
|
| + endTagOther(new EndTagToken("select"));
|
| + return token;
|
| + }
|
| + }
|
| +
|
| + Token endTagOther(EndTagToken token) {
|
| + return parser._inSelectPhase.processEndTag(token);
|
| + }
|
| +}
|
| +
|
| +
|
| +class InForeignContentPhase extends Phase {
|
| + // TODO(jmesserly): this is sorted so we could binary search.
|
| + static const breakoutElements = const [
|
| + 'b', 'big', 'blockquote', 'body', 'br','center', 'code', 'dd', 'div', 'dl',
|
| + 'dt', 'em', 'embed', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'hr', 'i',
|
| + 'img', 'li', 'listing', 'menu', 'meta', 'nobr', 'ol', 'p', 'pre', 'ruby',
|
| + 's', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'table', 'tt', 'u',
|
| + 'ul', 'var'
|
| + ];
|
| +
|
| + InForeignContentPhase(parser) : super(parser);
|
| +
|
| + void adjustSVGTagNames(token) {
|
| + final replacements = const {
|
| + "altglyph":"altGlyph",
|
| + "altglyphdef":"altGlyphDef",
|
| + "altglyphitem":"altGlyphItem",
|
| + "animatecolor":"animateColor",
|
| + "animatemotion":"animateMotion",
|
| + "animatetransform":"animateTransform",
|
| + "clippath":"clipPath",
|
| + "feblend":"feBlend",
|
| + "fecolormatrix":"feColorMatrix",
|
| + "fecomponenttransfer":"feComponentTransfer",
|
| + "fecomposite":"feComposite",
|
| + "feconvolvematrix":"feConvolveMatrix",
|
| + "fediffuselighting":"feDiffuseLighting",
|
| + "fedisplacementmap":"feDisplacementMap",
|
| + "fedistantlight":"feDistantLight",
|
| + "feflood":"feFlood",
|
| + "fefunca":"feFuncA",
|
| + "fefuncb":"feFuncB",
|
| + "fefuncg":"feFuncG",
|
| + "fefuncr":"feFuncR",
|
| + "fegaussianblur":"feGaussianBlur",
|
| + "feimage":"feImage",
|
| + "femerge":"feMerge",
|
| + "femergenode":"feMergeNode",
|
| + "femorphology":"feMorphology",
|
| + "feoffset":"feOffset",
|
| + "fepointlight":"fePointLight",
|
| + "fespecularlighting":"feSpecularLighting",
|
| + "fespotlight":"feSpotLight",
|
| + "fetile":"feTile",
|
| + "feturbulence":"feTurbulence",
|
| + "foreignobject":"foreignObject",
|
| + "glyphref":"glyphRef",
|
| + "lineargradient":"linearGradient",
|
| + "radialgradient":"radialGradient",
|
| + "textpath":"textPath"
|
| + };
|
| +
|
| + var replace = replacements[token.name];
|
| + if (replace != null) {
|
| + token.name = replace;
|
| + }
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + if (token.data == "\u0000") {
|
| + token.data = "\uFFFD";
|
| + } else if (parser.framesetOK && !allWhitespace(token.data)) {
|
| + parser.framesetOK = false;
|
| + }
|
| + super.processCharacters(token);
|
| + }
|
| +
|
| + Token processStartTag(StartTagToken token) {
|
| + var currentNode = tree.openElements.last;
|
| + if (breakoutElements.contains(token.name) ||
|
| + (token.name == "font" &&
|
| + (token.data.containsKey("color") ||
|
| + token.data.containsKey("face") ||
|
| + token.data.containsKey("size")))) {
|
| +
|
| + parser.parseError(token.span,
|
| + "unexpected-html-element-in-foreign-content", {'name': token.name});
|
| + while (tree.openElements.last.namespace !=
|
| + tree.defaultNamespace &&
|
| + !parser.isHTMLIntegrationPoint(tree.openElements.last) &&
|
| + !parser.isMathMLTextIntegrationPoint(tree.openElements.last)) {
|
| + tree.openElements.removeLast();
|
| + }
|
| + return token;
|
| +
|
| + } else {
|
| + if (currentNode.namespace == Namespaces.mathml) {
|
| + parser.adjustMathMLAttributes(token);
|
| + } else if (currentNode.namespace == Namespaces.svg) {
|
| + adjustSVGTagNames(token);
|
| + parser.adjustSVGAttributes(token);
|
| + }
|
| + parser.adjustForeignAttributes(token);
|
| + token.namespace = currentNode.namespace;
|
| + tree.insertElement(token);
|
| + if (token.selfClosing) {
|
| + tree.openElements.removeLast();
|
| + token.selfClosingAcknowledged = true;
|
| + }
|
| + }
|
| + }
|
| +
|
| + Token processEndTag(EndTagToken token) {
|
| + var nodeIndex = tree.openElements.length - 1;
|
| + var node = tree.openElements.last;
|
| + if (node.tagName != token.name) {
|
| + parser.parseError(token.span, "unexpected-end-tag", {"name": token.name});
|
| + }
|
| +
|
| + var newToken = null;
|
| + while (true) {
|
| + if (asciiUpper2Lower(node.tagName) == token.name) {
|
| + //XXX this isn't in the spec but it seems necessary
|
| + if (parser.phase == parser._inTableTextPhase) {
|
| + InTableTextPhase inTableText = parser.phase;
|
| + inTableText.flushCharacters();
|
| + parser.phase = inTableText.originalPhase;
|
| + }
|
| + while (tree.openElements.removeLast() != node) {
|
| + assert(tree.openElements.length > 0);
|
| + }
|
| + newToken = null;
|
| + break;
|
| + }
|
| + nodeIndex -= 1;
|
| +
|
| + node = tree.openElements[nodeIndex];
|
| + if (node.namespace != tree.defaultNamespace) {
|
| + continue;
|
| + } else {
|
| + newToken = parser.phase.processEndTag(token);
|
| + break;
|
| + }
|
| + }
|
| + return newToken;
|
| + }
|
| +}
|
| +
|
| +
|
| +class AfterBodyPhase extends Phase {
|
| + AfterBodyPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + if (token.name == "html") return startTagHtml(token);
|
| + return startTagOther(token);
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + if (token.name == "html") return endTagHtml(token);
|
| + return endTagOther(token);
|
| + }
|
| +
|
| + //Stop parsing
|
| + bool processEOF() => false;
|
| +
|
| + Token processComment(CommentToken token) {
|
| + // This is needed because data is to be appended to the <html> element
|
| + // here and not to whatever is currently open.
|
| + tree.insertComment(token, tree.openElements[0]);
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + parser.parseError(token.span, "unexpected-char-after-body");
|
| + parser.phase = parser._inBodyPhase;
|
| + return token;
|
| + }
|
| +
|
| + Token startTagHtml(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-after-body",
|
| + {"name": token.name});
|
| + parser.phase = parser._inBodyPhase;
|
| + return token;
|
| + }
|
| +
|
| + void endTagHtml(Token token) {
|
| + if (parser.innerHTMLMode) {
|
| + parser.parseError(token.span, "unexpected-end-tag-after-body-innerhtml");
|
| + } else {
|
| + parser.phase = parser._afterAfterBodyPhase;
|
| + }
|
| + }
|
| +
|
| + Token endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-after-body",
|
| + {"name": token.name});
|
| + parser.phase = parser._inBodyPhase;
|
| + return token;
|
| + }
|
| +}
|
| +
|
| +class InFramesetPhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///in-frameset
|
| + InFramesetPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "frameset": return startTagFrameset(token);
|
| + case "frame": return startTagFrame(token);
|
| + case "noframes": return startTagNoframes(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "frameset": return endTagFrameset(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool processEOF() {
|
| + var last = tree.openElements.last;
|
| + if (last.tagName != "html") {
|
| + parser.parseError(last.sourceSpan, "eof-in-frameset");
|
| + } else {
|
| + assert(parser.innerHTMLMode);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + parser.parseError(token.span, "unexpected-char-in-frameset");
|
| + }
|
| +
|
| + void startTagFrameset(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + }
|
| +
|
| + void startTagFrame(StartTagToken token) {
|
| + tree.insertElement(token);
|
| + tree.openElements.removeLast();
|
| + }
|
| +
|
| + Token startTagNoframes(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-in-frameset",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + void endTagFrameset(EndTagToken token) {
|
| + if (tree.openElements.last.tagName == "html") {
|
| + // innerHTML case
|
| + parser.parseError(token.span,
|
| + "unexpected-frameset-in-frameset-innerhtml");
|
| + } else {
|
| + tree.openElements.removeLast();
|
| + }
|
| + if (!parser.innerHTMLMode && tree.openElements.last.tagName != "frameset") {
|
| + // If we're not in innerHTML mode and the the current node is not a
|
| + // "frameset" element (anymore) then switch.
|
| + parser.phase = parser._afterFramesetPhase;
|
| + }
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-in-frameset",
|
| + {"name": token.name});
|
| + }
|
| +}
|
| +
|
| +
|
| +class AfterFramesetPhase extends Phase {
|
| + // http://www.whatwg.org/specs/web-apps/current-work///after3
|
| + AfterFramesetPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "noframes": return startTagNoframes(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + processEndTag(EndTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return endTagHtml(token);
|
| + default: return endTagOther(token);
|
| + }
|
| + }
|
| +
|
| + // Stop parsing
|
| + bool processEOF() => false;
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + parser.parseError(token.span, "unexpected-char-after-frameset");
|
| + }
|
| +
|
| + Token startTagNoframes(StartTagToken token) {
|
| + return parser._inHeadPhase.processStartTag(token);
|
| + }
|
| +
|
| + void startTagOther(StartTagToken token) {
|
| + parser.parseError(token.span, "unexpected-start-tag-after-frameset",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + void endTagHtml(EndTagToken token) {
|
| + parser.phase = parser._afterAfterFramesetPhase;
|
| + }
|
| +
|
| + void endTagOther(EndTagToken token) {
|
| + parser.parseError(token.span, "unexpected-end-tag-after-frameset",
|
| + {"name": token.name});
|
| + }
|
| +}
|
| +
|
| +
|
| +class AfterAfterBodyPhase extends Phase {
|
| + AfterAfterBodyPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + if (token.name == 'html') return startTagHtml(token);
|
| + return startTagOther(token);
|
| + }
|
| +
|
| + bool processEOF() => false;
|
| +
|
| + Token processComment(CommentToken token) {
|
| + tree.insertComment(token, tree.document);
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + return parser._inBodyPhase.processSpaceCharacters(token);
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + parser.parseError(token.span, "expected-eof-but-got-char");
|
| + parser.phase = parser._inBodyPhase;
|
| + return token;
|
| + }
|
| +
|
| + Token startTagHtml(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + Token startTagOther(StartTagToken token) {
|
| + parser.parseError(token.span, "expected-eof-but-got-start-tag",
|
| + {"name": token.name});
|
| + parser.phase = parser._inBodyPhase;
|
| + return token;
|
| + }
|
| +
|
| + Token processEndTag(EndTagToken token) {
|
| + parser.parseError(token.span, "expected-eof-but-got-end-tag",
|
| + {"name": token.name});
|
| + parser.phase = parser._inBodyPhase;
|
| + return token;
|
| + }
|
| +}
|
| +
|
| +class AfterAfterFramesetPhase extends Phase {
|
| + AfterAfterFramesetPhase(parser) : super(parser);
|
| +
|
| + processStartTag(StartTagToken token) {
|
| + switch (token.name) {
|
| + case "html": return startTagHtml(token);
|
| + case "noframes": return startTagNoFrames(token);
|
| + default: return startTagOther(token);
|
| + }
|
| + }
|
| +
|
| + bool processEOF() => false;
|
| +
|
| + Token processComment(CommentToken token) {
|
| + tree.insertComment(token, tree.document);
|
| + }
|
| +
|
| + Token processSpaceCharacters(SpaceCharactersToken token) {
|
| + return parser._inBodyPhase.processSpaceCharacters(token);
|
| + }
|
| +
|
| + Token processCharacters(CharactersToken token) {
|
| + parser.parseError(token.span, "expected-eof-but-got-char");
|
| + }
|
| +
|
| + Token startTagHtml(StartTagToken token) {
|
| + return parser._inBodyPhase.processStartTag(token);
|
| + }
|
| +
|
| + Token startTagNoFrames(StartTagToken token) {
|
| + return parser._inHeadPhase.processStartTag(token);
|
| + }
|
| +
|
| + void startTagOther(StartTagToken token) {
|
| + parser.parseError(token.span, "expected-eof-but-got-start-tag",
|
| + {"name": token.name});
|
| + }
|
| +
|
| + Token processEndTag(EndTagToken token) {
|
| + parser.parseError(token.span, "expected-eof-but-got-end-tag",
|
| + {"name": token.name});
|
| + }
|
| +}
|
| +
|
| +
|
| +/** Error in parsed document. */
|
| +class ParseError implements Exception {
|
| + final String errorCode;
|
| + final Span span;
|
| + final Map data;
|
| +
|
| + ParseError(this.errorCode, this.span, this.data);
|
| +
|
| + int get line => span.start.line;
|
| +
|
| + int get column => span.start.column;
|
| +
|
| + /**
|
| + * Gets the human readable error message for this error. Use
|
| + * [span.getLocationMessage] or [toString] to get a message including span
|
| + * information. If there is a file associated with the span, both
|
| + * [span.getLocationMessage] and [toString] are equivalent. Otherwise,
|
| + * [span.getLocationMessage] will not show any source url information, but
|
| + * [toString] will include 'ParserError:' as a prefix.
|
| + */
|
| + String get message => formatStr(errorMessages[errorCode], data);
|
| +
|
| + String toString() {
|
| + var res = span.getLocationMessage(message);
|
| + return span.sourceUrl == null ? 'ParserError$res' : res;
|
| + }
|
| +}
|
|
|
Chromium Code Reviews
Issue 22375011:
move html5lib code into dart svn repo (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart