// Copyright 2010 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: jdtang@google.com (Jonathan Tang)
#include <assert.h>
#include <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "attribute.h"
#include "error.h"
#include "gumbo.h"
#include "insertion_mode.h"
#include "parser.h"
#include "tokenizer.h"
#include "tokenizer_states.h"
#include "utf8.h"
#include "util.h"
#include "vector.h"
#define AVOID_UNUSED_VARIABLE_WARNING(i) (void)(i)
#define GUMBO_STRING(literal) \
{ literal, sizeof(literal) - 1 }
#define TERMINATOR \
{ "", 0 }
typedef char gumbo_tagset[GUMBO_TAG_LAST];
#define TAG(tag) [GUMBO_TAG_##tag] = (1 << GUMBO_NAMESPACE_HTML)
#define TAG_SVG(tag) [GUMBO_TAG_##tag] = (1 << GUMBO_NAMESPACE_SVG)
#define TAG_MATHML(tag) [GUMBO_TAG_##tag] = (1 << GUMBO_NAMESPACE_MATHML)
#define TAGSET_INCLUDES(tagset, namespace, tag) \
(tag < GUMBO_TAG_LAST && tagset[(int) tag] & (1 << (int) namespace))
// selected forward declarations as it is getting hard to find
// an appropriate order
static bool node_html_tag_is(const GumboNode*, GumboTag);
static GumboInsertionMode get_current_template_insertion_mode(
const GumboParser*);
static bool handle_in_template(GumboParser*, GumboToken*);
static void destroy_node(GumboParser*, GumboNode*);
static void* malloc_wrapper(void* unused, size_t size) { return malloc(size); }
static void free_wrapper(void* unused, void* ptr) { free(ptr); }
const GumboOptions kGumboDefaultOptions = {&malloc_wrapper, &free_wrapper, NULL,
8, false, -1, GUMBO_TAG_LAST, GUMBO_NAMESPACE_HTML};
static const GumboStringPiece kDoctypeHtml = GUMBO_STRING("html");
static const GumboStringPiece kPublicIdHtml4_0 =
GUMBO_STRING("-//W3C//DTD HTML 4.0//EN");
static const GumboStringPiece kPublicIdHtml4_01 =
GUMBO_STRING("-//W3C//DTD HTML 4.01//EN");
static const GumboStringPiece kPublicIdXhtml1_0 =
GUMBO_STRING("-//W3C//DTD XHTML 1.0 Strict//EN");
static const GumboStringPiece kPublicIdXhtml1_1 =
GUMBO_STRING("-//W3C//DTD XHTML 1.1//EN");
static const GumboStringPiece kSystemIdRecHtml4_0 =
GUMBO_STRING("http://www.w3.org/TR/REC-html40/strict.dtd");
static const GumboStringPiece kSystemIdHtml4 =
GUMBO_STRING("http://www.w3.org/TR/html4/strict.dtd");
static const GumboStringPiece kSystemIdXhtmlStrict1_1 =
GUMBO_STRING("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd");
static const GumboStringPiece kSystemIdXhtml1_1 =
GUMBO_STRING("http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd");
static const GumboStringPiece kSystemIdLegacyCompat =
GUMBO_STRING("about:legacy-compat");
// The doctype arrays have an explicit terminator because we want to pass them
// to a helper function, and passing them as a pointer discards sizeof
// information. The SVG arrays are used only by one-off functions, and so loops
// over them use sizeof directly instead of a terminator.
static const GumboStringPiece kQuirksModePublicIdPrefixes[] = {
GUMBO_STRING("+//Silmaril//dtd html Pro v0r11 19970101//"),
GUMBO_STRING("-//AdvaSoft Ltd//DTD HTML 3.0 asWedit + extensions//"),
GUMBO_STRING("-//AS//DTD HTML 3.0 asWedit + extensions//"),
GUMBO_STRING("-//IETF//DTD HTML 2.0 Level 1//"),
GUMBO_STRING("-//IETF//DTD HTML 2.0 Level 2//"),
GUMBO_STRING("-//IETF//DTD HTML 2.0 Strict Level 1//"),
GUMBO_STRING("-//IETF//DTD HTML 2.0 Strict Level 2//"),
GUMBO_STRING("-//IETF//DTD HTML 2.0 Strict//"),
GUMBO_STRING("-//IETF//DTD HTML 2.0//"),
GUMBO_STRING("-//IETF//DTD HTML 2.1E//"),
GUMBO_STRING("-//IETF//DTD HTML 3.0//"),
GUMBO_STRING("-//IETF//DTD HTML 3.2 Final//"),
GUMBO_STRING("-//IETF//DTD HTML 3.2//"),
GUMBO_STRING("-//IETF//DTD HTML 3//"),
GUMBO_STRING("-//IETF//DTD HTML Level 0//"),
GUMBO_STRING("-//IETF//DTD HTML Level 1//"),
GUMBO_STRING("-//IETF//DTD HTML Level 2//"),
GUMBO_STRING("-//IETF//DTD HTML Level 3//"),
GUMBO_STRING("-//IETF//DTD HTML Strict Level 0//"),
GUMBO_STRING("-//IETF//DTD HTML Strict Level 1//"),
GUMBO_STRING("-//IETF//DTD HTML Strict Level 2//"),
GUMBO_STRING("-//IETF//DTD HTML Strict Level 3//"),
GUMBO_STRING("-//IETF//DTD HTML Strict//"),
GUMBO_STRING("-//IETF//DTD HTML//"),
GUMBO_STRING("-//Metrius//DTD Metrius Presentational//"),
GUMBO_STRING("-//Microsoft//DTD Internet Explorer 2.0 HTML Strict//"),
GUMBO_STRING("-//Microsoft//DTD Internet Explorer 2.0 HTML//"),
GUMBO_STRING("-//Microsoft//DTD Internet Explorer 2.0 Tables//"),
GUMBO_STRING("-//Microsoft//DTD Internet Explorer 3.0 HTML Strict//"),
GUMBO_STRING("-//Microsoft//DTD Internet Explorer 3.0 HTML//"),
GUMBO_STRING("-//Microsoft//DTD Internet Explorer 3.0 Tables//"),
GUMBO_STRING("-//Netscape Comm. Corp.//DTD HTML//"),
GUMBO_STRING("-//Netscape Comm. Corp.//DTD Strict HTML//"),
GUMBO_STRING("-//O'Reilly and Associates//DTD HTML 2.0//"),
GUMBO_STRING("-//O'Reilly and Associates//DTD HTML Extended 1.0//"),
GUMBO_STRING("-//O'Reilly and Associates//DTD HTML Extended Relaxed 1.0//"),
GUMBO_STRING(
"-//SoftQuad Software//DTD HoTMetaL PRO 6.0::19990601::)"
"extensions to HTML 4.0//"),
GUMBO_STRING(
"-//SoftQuad//DTD HoTMetaL PRO 4.0::19971010::"
"extensions to HTML 4.0//"),
GUMBO_STRING("-//Spyglass//DTD HTML 2.0 Extended//"),
GUMBO_STRING("-//SQ//DTD HTML 2.0 HoTMetaL + extensions//"),
GUMBO_STRING("-//Sun Microsystems Corp.//DTD HotJava HTML//"),
GUMBO_STRING("-//Sun Microsystems Corp.//DTD HotJava Strict HTML//"),
GUMBO_STRING("-//W3C//DTD HTML 3 1995-03-24//"),
GUMBO_STRING("-//W3C//DTD HTML 3.2 Draft//"),
GUMBO_STRING("-//W3C//DTD HTML 3.2 Final//"),
GUMBO_STRING("-//W3C//DTD HTML 3.2//"),
GUMBO_STRING("-//W3C//DTD HTML 3.2S Draft//"),
GUMBO_STRING("-//W3C//DTD HTML 4.0 Frameset//"),
GUMBO_STRING("-//W3C//DTD HTML 4.0 Transitional//"),
GUMBO_STRING("-//W3C//DTD HTML Experimental 19960712//"),
GUMBO_STRING("-//W3C//DTD HTML Experimental 970421//"),
GUMBO_STRING("-//W3C//DTD W3 HTML//"),
GUMBO_STRING("-//W3O//DTD W3 HTML 3.0//"),
GUMBO_STRING("-//WebTechs//DTD Mozilla HTML 2.0//"),
GUMBO_STRING("-//WebTechs//DTD Mozilla HTML//"), TERMINATOR};
static const GumboStringPiece kQuirksModePublicIdExactMatches[] = {
GUMBO_STRING("-//W3O//DTD W3 HTML Strict 3.0//EN//"),
GUMBO_STRING("-/W3C/DTD HTML 4.0 Transitional/EN"), GUMBO_STRING("HTML"),
TERMINATOR};
static const GumboStringPiece kQuirksModeSystemIdExactMatches[] = {
GUMBO_STRING("http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"),
TERMINATOR};
static const GumboStringPiece kLimitedQuirksPublicIdPrefixes[] = {
GUMBO_STRING("-//W3C//DTD XHTML 1.0 Frameset//"),
GUMBO_STRING("-//W3C//DTD XHTML 1.0 Transitional//"), TERMINATOR};
static const GumboStringPiece kLimitedQuirksRequiresSystemIdPublicIdPrefixes[] =
{GUMBO_STRING("-//W3C//DTD HTML 4.01 Frameset//"),
GUMBO_STRING("-//W3C//DTD HTML 4.01 Transitional//"), TERMINATOR};
// Indexed by GumboNamespaceEnum; keep in sync with that.
static const char* kLegalXmlns[] = {"http://www.w3.org/1999/xhtml",
"http://www.w3.org/2000/svg", "http://www.w3.org/1998/Math/MathML"};
typedef struct _ReplacementEntry {
const GumboStringPiece from;
const GumboStringPiece to;
} ReplacementEntry;
#define REPLACEMENT_ENTRY(from, to) \
{ GUMBO_STRING(from), GUMBO_STRING(to) }
// Static data for SVG attribute replacements.
// https://html.spec.whatwg.org/multipage/syntax.html#creating-and-inserting-nodes
static const ReplacementEntry kSvgAttributeReplacements[] = {
REPLACEMENT_ENTRY("attributename", "attributeName"),
REPLACEMENT_ENTRY("attributetype", "attributeType"),
REPLACEMENT_ENTRY("basefrequency", "baseFrequency"),
REPLACEMENT_ENTRY("baseprofile", "baseProfile"),
REPLACEMENT_ENTRY("calcmode", "calcMode"),
REPLACEMENT_ENTRY("clippathunits", "clipPathUnits"),
// REPLACEMENT_ENTRY("contentscripttype", "contentScriptType"),
// REPLACEMENT_ENTRY("contentstyletype", "contentStyleType"),
REPLACEMENT_ENTRY("diffuseconstant", "diffuseConstant"),
REPLACEMENT_ENTRY("edgemode", "edgeMode"),
// REPLACEMENT_ENTRY("externalresourcesrequired",
// "externalResourcesRequired"),
// REPLACEMENT_ENTRY("filterres", "filterRes"),
REPLACEMENT_ENTRY("filterunits", "filterUnits"),
REPLACEMENT_ENTRY("glyphref", "glyphRef"),
REPLACEMENT_ENTRY("gradienttransform", "gradientTransform"),
REPLACEMENT_ENTRY("gradientunits", "gradientUnits"),
REPLACEMENT_ENTRY("kernelmatrix", "kernelMatrix"),
REPLACEMENT_ENTRY("kernelunitlength", "kernelUnitLength"),
REPLACEMENT_ENTRY("keypoints", "keyPoints"),
REPLACEMENT_ENTRY("keysplines", "keySplines"),
REPLACEMENT_ENTRY("keytimes", "keyTimes"),
REPLACEMENT_ENTRY("lengthadjust", "lengthAdjust"),
REPLACEMENT_ENTRY("limitingconeangle", "limitingConeAngle"),
REPLACEMENT_ENTRY("markerheight", "markerHeight"),
REPLACEMENT_ENTRY("markerunits", "markerUnits"),
REPLACEMENT_ENTRY("markerwidth", "markerWidth"),
REPLACEMENT_ENTRY("maskcontentunits", "maskContentUnits"),
REPLACEMENT_ENTRY("maskunits", "maskUnits"),
REPLACEMENT_ENTRY("numoctaves", "numOctaves"),
REPLACEMENT_ENTRY("pathlength", "pathLength"),
REPLACEMENT_ENTRY("patterncontentunits", "patternContentUnits"),
REPLACEMENT_ENTRY("patterntransform", "patternTransform"),
REPLACEMENT_ENTRY("patternunits", "patternUnits"),
REPLACEMENT_ENTRY("pointsatx", "pointsAtX"),
REPLACEMENT_ENTRY("pointsaty", "pointsAtY"),
REPLACEMENT_ENTRY("pointsatz", "pointsAtZ"),
REPLACEMENT_ENTRY("preservealpha", "preserveAlpha"),
REPLACEMENT_ENTRY("preserveaspectratio", "preserveAspectRatio"),
REPLACEMENT_ENTRY("primitiveunits", "primitiveUnits"),
REPLACEMENT_ENTRY("refx", "refX"), REPLACEMENT_ENTRY("refy", "refY"),
REPLACEMENT_ENTRY("repeatcount", "repeatCount"),
REPLACEMENT_ENTRY("repeatdur", "repeatDur"),
REPLACEMENT_ENTRY("requiredextensions", "requiredExtensions"),
REPLACEMENT_ENTRY("requiredfeatures", "requiredFeatures"),
REPLACEMENT_ENTRY("specularconstant", "specularConstant"),
REPLACEMENT_ENTRY("specularexponent", "specularExponent"),
REPLACEMENT_ENTRY("spreadmethod", "spreadMethod"),
REPLACEMENT_ENTRY("startoffset", "startOffset"),
REPLACEMENT_ENTRY("stddeviation", "stdDeviation"),
REPLACEMENT_ENTRY("stitchtiles", "stitchTiles"),
REPLACEMENT_ENTRY("surfacescale", "surfaceScale"),
REPLACEMENT_ENTRY("systemlanguage", "systemLanguage"),
REPLACEMENT_ENTRY("tablevalues", "tableValues"),
REPLACEMENT_ENTRY("targetx", "targetX"),
REPLACEMENT_ENTRY("targety", "targetY"),
REPLACEMENT_ENTRY("textlength", "textLength"),
REPLACEMENT_ENTRY("viewbox", "viewBox"),
REPLACEMENT_ENTRY("viewtarget", "viewTarget"),
REPLACEMENT_ENTRY("xchannelselector", "xChannelSelector"),
REPLACEMENT_ENTRY("ychannelselector", "yChannelSelector"),
REPLACEMENT_ENTRY("zoomandpan", "zoomAndPan"),
};
static const ReplacementEntry kSvgTagReplacements[] = {
REPLACEMENT_ENTRY("altglyph", "altGlyph"),
REPLACEMENT_ENTRY("altglyphdef", "altGlyphDef"),
REPLACEMENT_ENTRY("altglyphitem", "altGlyphItem"),
REPLACEMENT_ENTRY("animatecolor", "animateColor"),
REPLACEMENT_ENTRY("animatemotion", "animateMotion"),
REPLACEMENT_ENTRY("animatetransform", "animateTransform"),
REPLACEMENT_ENTRY("clippath", "clipPath"),
REPLACEMENT_ENTRY("feblend", "feBlend"),
REPLACEMENT_ENTRY("fecolormatrix", "feColorMatrix"),
REPLACEMENT_ENTRY("fecomponenttransfer", "feComponentTransfer"),
REPLACEMENT_ENTRY("fecomposite", "feComposite"),
REPLACEMENT_ENTRY("feconvolvematrix", "feConvolveMatrix"),
REPLACEMENT_ENTRY("fediffuselighting", "feDiffuseLighting"),
REPLACEMENT_ENTRY("fedisplacementmap", "feDisplacementMap"),
REPLACEMENT_ENTRY("fedistantlight", "feDistantLight"),
REPLACEMENT_ENTRY("feflood", "feFlood"),
REPLACEMENT_ENTRY("fefunca", "feFuncA"),
REPLACEMENT_ENTRY("fefuncb", "feFuncB"),
REPLACEMENT_ENTRY("fefuncg", "feFuncG"),
REPLACEMENT_ENTRY("fefuncr", "feFuncR"),
REPLACEMENT_ENTRY("fegaussianblur", "feGaussianBlur"),
REPLACEMENT_ENTRY("feimage", "feImage"),
REPLACEMENT_ENTRY("femerge", "feMerge"),
REPLACEMENT_ENTRY("femergenode", "feMergeNode"),
REPLACEMENT_ENTRY("femorphology", "feMorphology"),
REPLACEMENT_ENTRY("feoffset", "feOffset"),
REPLACEMENT_ENTRY("fepointlight", "fePointLight"),
REPLACEMENT_ENTRY("fespecularlighting", "feSpecularLighting"),
REPLACEMENT_ENTRY("fespotlight", "feSpotLight"),
REPLACEMENT_ENTRY("fetile", "feTile"),
REPLACEMENT_ENTRY("feturbulence", "feTurbulence"),
REPLACEMENT_ENTRY("foreignobject", "foreignObject"),
REPLACEMENT_ENTRY("glyphref", "glyphRef"),
REPLACEMENT_ENTRY("lineargradient", "linearGradient"),
REPLACEMENT_ENTRY("radialgradient", "radialGradient"),
REPLACEMENT_ENTRY("textpath", "textPath"),
};
typedef struct _NamespacedAttributeReplacement {
const char* from;
const char* local_name;
const GumboAttributeNamespaceEnum attr_namespace;
} NamespacedAttributeReplacement;
static const NamespacedAttributeReplacement kForeignAttributeReplacements[] = {
{"xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK},
{"xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK},
{"xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK},
{"xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK},
{"xlink:show", "show", GUMBO_ATTR_NAMESPACE_XLINK},
{"xlink:title", "title", GUMBO_ATTR_NAMESPACE_XLINK},
{"xlink:type", "type", GUMBO_ATTR_NAMESPACE_XLINK},
{"xml:base", "base", GUMBO_ATTR_NAMESPACE_XML},
{"xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML},
{"xml:space", "space", GUMBO_ATTR_NAMESPACE_XML},
{"xmlns", "xmlns", GUMBO_ATTR_NAMESPACE_XMLNS},
{"xmlns:xlink", "xlink", GUMBO_ATTR_NAMESPACE_XMLNS},
};
// The "scope marker" for the list of active formatting elements. We use a
// pointer to this as a generic marker element, since the particular element
// scope doesn't matter.
static const GumboNode kActiveFormattingScopeMarker;
// The tag_is and tag_in function use true & false to denote start & end tags,
// but for readability, we define constants for them here.
static const bool kStartTag = true;
static const bool kEndTag = false;
// Because GumboStringPieces are immutable, we can't insert a character directly
// into a text node. Instead, we accumulate all pending characters here and
// flush them out to a text node whenever a new element is inserted.
//
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#insert-a-character
typedef struct _TextNodeBufferState {
// The accumulated text to be inserted into the current text node.
GumboStringBuffer _buffer;
// A pointer to the original text represented by this text node. Note that
// because of foster parenting and other strange DOM manipulations, this may
// include other non-text HTML tags in it; it is defined as the span of
// original text from the first character in this text node to the last
// character in this text node.
const char* _start_original_text;
// The source position of the start of this text node.
GumboSourcePosition _start_position;
// The type of node that will be inserted (TEXT, CDATA, or WHITESPACE).
GumboNodeType _type;
} TextNodeBufferState;
typedef struct GumboInternalParserState {
// http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#insertion-mode
GumboInsertionMode _insertion_mode;
// Used for run_generic_parsing_algorithm, which needs to switch back to the
// original insertion mode at its conclusion.
GumboInsertionMode _original_insertion_mode;
// http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#the-stack-of-open-elements
GumboVector /*GumboNode*/ _open_elements;
// http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#the-list-of-active-formatting-elements
GumboVector /*GumboNode*/ _active_formatting_elements;
// The stack of template insertion modes.
// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#the-insertion-mode
GumboVector /*InsertionMode*/ _template_insertion_modes;
// http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#the-element-pointers
GumboNode* _head_element;
GumboNode* _form_element;
// The element used as fragment context when parsing in fragment mode
GumboNode* _fragment_ctx;
// The flag for when the spec says "Reprocess the current token in..."
bool _reprocess_current_token;
// The flag for "acknowledge the token's self-closing flag".
bool _self_closing_flag_acknowledged;
// The "frameset-ok" flag from the spec.
bool _frameset_ok;
// The flag for "If the next token is a LINE FEED, ignore that token...".
bool _ignore_next_linefeed;
// The flag for "whenever a node would be inserted into the current node, it
// must instead be foster parented". This is used for misnested table
// content, which needs to be handled according to "in body" rules yet foster
// parented outside of the table.
// It would perhaps be more explicit to have this as a parameter to
// handle_in_body and insert_element, but given how special-purpose this is
// and the number of call-sites that would need to take the extra parameter,
// it's easier just to have a state flag.
bool _foster_parent_insertions;
// The accumulated text node buffer state.
TextNodeBufferState _text_node;
// The current token.
GumboToken* _current_token;
// The way that the spec is written, the </body> and </html> tags are *always*
// implicit, because encountering one of those tokens merely switches the
// insertion mode out of "in body". So we have individual state flags for
// those end tags that are then inspected by pop_current_node when the <body>
// and <html> nodes are popped to set the GUMBO_INSERTION_IMPLICIT_END_TAG
// flag appropriately.
bool _closed_body_tag;
bool _closed_html_tag;
} GumboParserState;
static bool token_has_attribute(const GumboToken* token, const char* name) {
assert(token->type == GUMBO_TOKEN_START_TAG);
return gumbo_get_attribute(&token->v.start_tag.attributes, name) != NULL;
}
// Checks if the value of the specified attribute is a case-insensitive match
// for the specified string.
static bool attribute_matches(
const GumboVector* attributes, const char* name, const char* value) {
const GumboAttribute* attr = gumbo_get_attribute(attributes, name);
return attr ? strcasecmp(value, attr->value) == 0 : false;
}
// Checks if the value of the specified attribute is a case-sensitive match
// for the specified string.
static bool attribute_matches_case_sensitive(
const GumboVector* attributes, const char* name, const char* value) {
const GumboAttribute* attr = gumbo_get_attribute(attributes, name);
return attr ? strcmp(value, attr->value) == 0 : false;
}
// Checks if the specified attribute vectors are identical.
static bool all_attributes_match(
const GumboVector* attr1, const GumboVector* attr2) {
unsigned int num_unmatched_attr2_elements = attr2->length;
for (unsigned int i = 0; i < attr1->length; ++i) {
const GumboAttribute* attr = attr1->data[i];
if (attribute_matches_case_sensitive(attr2, attr->name, attr->value)) {
--num_unmatched_attr2_elements;
} else {
return false;
}
}
return num_unmatched_attr2_elements == 0;
}
static void set_frameset_not_ok(GumboParser* parser) {
gumbo_debug("Setting frameset_ok to false.\n");
parser->_parser_state->_frameset_ok = false;
}
static GumboNode* create_node(GumboParser* parser, GumboNodeType type) {
GumboNode* node = gumbo_parser_allocate(parser, sizeof(GumboNode));
node->parent = NULL;
node->index_within_parent = -1;
node->type = type;
node->parse_flags = GUMBO_INSERTION_NORMAL;
return node;
}
static GumboNode* new_document_node(GumboParser* parser) {
GumboNode* document_node = create_node(parser, GUMBO_NODE_DOCUMENT);
document_node->parse_flags = GUMBO_INSERTION_BY_PARSER;
gumbo_vector_init(parser, 1, &document_node->v.document.children);
// Must be initialized explicitly, as there's no guarantee that we'll see a
// doc type token.
GumboDocument* document = &document_node->v.document;
document->has_doctype = false;
document->name = NULL;
document->public_identifier = NULL;
document->system_identifier = NULL;
return document_node;
}
static void output_init(GumboParser* parser) {
GumboOutput* output = gumbo_parser_allocate(parser, sizeof(GumboOutput));
output->root = NULL;
output->document = new_document_node(parser);
parser->_output = output;
gumbo_init_errors(parser);
}
static void parser_state_init(GumboParser* parser) {
GumboParserState* parser_state =
gumbo_parser_allocate(parser, sizeof(GumboParserState));
parser_state->_insertion_mode = GUMBO_INSERTION_MODE_INITIAL;
parser_state->_reprocess_current_token = false;
parser_state->_frameset_ok = true;
parser_state->_ignore_next_linefeed = false;
parser_state->_foster_parent_insertions = false;
parser_state->_text_node._type = GUMBO_NODE_WHITESPACE;
gumbo_string_buffer_init(parser, &parser_state->_text_node._buffer);
gumbo_vector_init(parser, 10, &parser_state->_open_elements);
gumbo_vector_init(parser, 5, &parser_state->_active_formatting_elements);
gumbo_vector_init(parser, 5, &parser_state->_template_insertion_modes);
parser_state->_head_element = NULL;
parser_state->_form_element = NULL;
parser_state->_fragment_ctx = NULL;
parser_state->_current_token = NULL;
parser_state->_closed_body_tag = false;
parser_state->_closed_html_tag = false;
parser->_parser_state = parser_state;
}
static void parser_state_destroy(GumboParser* parser) {
GumboParserState* state = parser->_parser_state;
if (state->_fragment_ctx) {
destroy_node(parser, state->_fragment_ctx);
}
gumbo_vector_destroy(parser, &state->_active_formatting_elements);
gumbo_vector_destroy(parser, &state->_open_elements);
gumbo_vector_destroy(parser, &state->_template_insertion_modes);
gumbo_string_buffer_destroy(parser, &state->_text_node._buffer);
gumbo_parser_deallocate(parser, state);
}
static GumboNode* get_document_node(GumboParser* parser) {
return parser->_output->document;
}
static bool is_fragment_parser(const GumboParser* parser) {
return !!parser->_parser_state->_fragment_ctx;
}
// Returns the node at the bottom of the stack of open elements, or NULL if no
// elements have been added yet.
static GumboNode* get_current_node(GumboParser* parser) {
GumboVector* open_elements = &parser->_parser_state->_open_elements;
if (open_elements->length == 0) {
assert(!parser->_output->root);
return NULL;
}
assert(open_elements->length > 0);
assert(open_elements->data != NULL);
return open_elements->data[open_elements->length - 1];
}
static GumboNode* get_adjusted_current_node(GumboParser* parser) {
GumboParserState* state = parser->_parser_state;
if (state->_open_elements.length == 1 && state->_fragment_ctx) {
return state->_fragment_ctx;
}
return get_current_node(parser);
}
// Returns true if the given needle is in the given array of literal
// GumboStringPieces. If exact_match is true, this requires that they match
// exactly; otherwise, this performs a prefix match to check if any of the
// elements in haystack start with needle. This always performs a
// case-insensitive match.
static bool is_in_static_list(
const char* needle, const GumboStringPiece* haystack, bool exact_match) {
for (unsigned int i = 0; haystack[i].length > 0; ++i) {
if ((exact_match && !strcmp(needle, haystack[i].data)) ||
(!exact_match && !strcasecmp(needle, haystack[i].data))) {
return true;
}
}
return false;
}
static void set_insertion_mode(GumboParser* parser, GumboInsertionMode mode) {
parser->_parser_state->_insertion_mode = mode;
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#reset-the-insertion-mode-appropriately
// This is a helper function that returns the appropriate insertion mode instead
// of setting it. Returns GUMBO_INSERTION_MODE_INITIAL as a sentinel value to
// indicate that there is no appropriate insertion mode, and the loop should
// continue.
static GumboInsertionMode get_appropriate_insertion_mode(
const GumboParser* parser, int index) {
const GumboVector* open_elements = &parser->_parser_state->_open_elements;
const GumboNode* node = open_elements->data[index];
const bool is_last = index == 0;
if (is_last && is_fragment_parser(parser)) {
node = parser->_parser_state->_fragment_ctx;
}
assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
if (node->v.element.tag_namespace != GUMBO_NAMESPACE_HTML)
return is_last ?
GUMBO_INSERTION_MODE_IN_BODY : GUMBO_INSERTION_MODE_INITIAL;
switch (node->v.element.tag) {
case GUMBO_TAG_SELECT: {
if (is_last) {
return GUMBO_INSERTION_MODE_IN_SELECT;
}
for (int i = index; i > 0; --i) {
const GumboNode* ancestor = open_elements->data[i];
if (node_html_tag_is(ancestor, GUMBO_TAG_TEMPLATE)) {
return GUMBO_INSERTION_MODE_IN_SELECT;
}
if (node_html_tag_is(ancestor, GUMBO_TAG_TABLE)) {
return GUMBO_INSERTION_MODE_IN_SELECT_IN_TABLE;
}
}
return GUMBO_INSERTION_MODE_IN_SELECT;
}
case GUMBO_TAG_TD:
case GUMBO_TAG_TH:
if (!is_last) return GUMBO_INSERTION_MODE_IN_CELL;
break;
case GUMBO_TAG_TR:
return GUMBO_INSERTION_MODE_IN_ROW;
case GUMBO_TAG_TBODY:
case GUMBO_TAG_THEAD:
case GUMBO_TAG_TFOOT:
return GUMBO_INSERTION_MODE_IN_TABLE_BODY;
case GUMBO_TAG_CAPTION:
return GUMBO_INSERTION_MODE_IN_CAPTION;
case GUMBO_TAG_COLGROUP:
return GUMBO_INSERTION_MODE_IN_COLUMN_GROUP;
case GUMBO_TAG_TABLE:
return GUMBO_INSERTION_MODE_IN_TABLE;
case GUMBO_TAG_TEMPLATE:
return get_current_template_insertion_mode(parser);
case GUMBO_TAG_HEAD:
if (!is_last) return GUMBO_INSERTION_MODE_IN_HEAD;
break;
case GUMBO_TAG_BODY:
return GUMBO_INSERTION_MODE_IN_BODY;
case GUMBO_TAG_FRAMESET:
return GUMBO_INSERTION_MODE_IN_FRAMESET;
case GUMBO_TAG_HTML:
return parser->_parser_state->_head_element
? GUMBO_INSERTION_MODE_AFTER_HEAD
: GUMBO_INSERTION_MODE_BEFORE_HEAD;
default:
break;
}
return is_last ? GUMBO_INSERTION_MODE_IN_BODY : GUMBO_INSERTION_MODE_INITIAL;
}
// This performs the actual "reset the insertion mode" loop.
static void reset_insertion_mode_appropriately(GumboParser* parser) {
const GumboVector* open_elements = &parser->_parser_state->_open_elements;
for (int i = open_elements->length; --i >= 0;) {
GumboInsertionMode mode = get_appropriate_insertion_mode(parser, i);
if (mode != GUMBO_INSERTION_MODE_INITIAL) {
set_insertion_mode(parser, mode);
return;
}
}
// Should never get here, because is_last will be set on the last iteration
// and will force GUMBO_INSERTION_MODE_IN_BODY.
assert(0);
}
static GumboError* parser_add_parse_error(
GumboParser* parser, const GumboToken* token) {
gumbo_debug("Adding parse error.\n");
GumboError* error = gumbo_add_error(parser);
if (!error) {
return NULL;
}
error->type = GUMBO_ERR_PARSER;
error->position = token->position;
error->original_text = token->original_text.data;
GumboParserError* extra_data = &error->v.parser;
extra_data->input_type = token->type;
extra_data->input_tag = GUMBO_TAG_UNKNOWN;
if (token->type == GUMBO_TOKEN_START_TAG) {
extra_data->input_tag = token->v.start_tag.tag;
} else if (token->type == GUMBO_TOKEN_END_TAG) {
extra_data->input_tag = token->v.end_tag;
}
GumboParserState* state = parser->_parser_state;
extra_data->parser_state = state->_insertion_mode;
gumbo_vector_init(
parser, state->_open_elements.length, &extra_data->tag_stack);
for (unsigned int i = 0; i < state->_open_elements.length; ++i) {
const GumboNode* node = state->_open_elements.data[i];
assert(
node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
gumbo_vector_add(
parser, (void*) node->v.element.tag, &extra_data->tag_stack);
}
return error;
}
// Returns true if the specified token is either a start or end tag (specified
// by is_start) with one of the tag types in the varargs list. Terminate the
// list with GUMBO_TAG_LAST; this functions as a sentinel since no portion of
// the spec references tags that are not in the spec.
static bool tag_in(
const GumboToken* token, bool is_start, const gumbo_tagset tags) {
GumboTag token_tag;
if (is_start && token->type == GUMBO_TOKEN_START_TAG) {
token_tag = token->v.start_tag.tag;
} else if (!is_start && token->type == GUMBO_TOKEN_END_TAG) {
token_tag = token->v.end_tag;
} else {
return false;
}
return (token_tag < GUMBO_TAG_LAST && tags[(int) token_tag] != 0);
}
// Like tag_in, but for the single-tag case.
static bool tag_is(const GumboToken* token, bool is_start, GumboTag tag) {
if (is_start && token->type == GUMBO_TOKEN_START_TAG) {
return token->v.start_tag.tag == tag;
} else if (!is_start && token->type == GUMBO_TOKEN_END_TAG) {
return token->v.end_tag == tag;
} else {
return false;
}
}
// Like tag_in, but checks for the tag of a node, rather than a token.
static bool node_tag_in_set(const GumboNode* node, const gumbo_tagset tags) {
assert(node != NULL);
if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE) {
return false;
}
return TAGSET_INCLUDES(
tags, node->v.element.tag_namespace, node->v.element.tag);
}
// Like node_tag_in, but for the single-tag case.
static bool node_qualified_tag_is(
const GumboNode* node, GumboNamespaceEnum ns, GumboTag tag) {
assert(node);
return (node->type == GUMBO_NODE_ELEMENT ||
node->type == GUMBO_NODE_TEMPLATE) &&
node->v.element.tag == tag && node->v.element.tag_namespace == ns;
}
// Like node_tag_in, but for the single-tag case in the HTML namespace
static bool node_html_tag_is(const GumboNode* node, GumboTag tag) {
return node_qualified_tag_is(node, GUMBO_NAMESPACE_HTML, tag);
}
static void push_template_insertion_mode(
GumboParser* parser, GumboInsertionMode mode) {
gumbo_vector_add(
parser, (void*) mode, &parser->_parser_state->_template_insertion_modes);
}
static void pop_template_insertion_mode(GumboParser* parser) {
gumbo_vector_pop(parser, &parser->_parser_state->_template_insertion_modes);
}
// Returns the current template insertion mode. If the stack of template
// insertion modes is empty, this returns GUMBO_INSERTION_MODE_INITIAL.
static GumboInsertionMode get_current_template_insertion_mode(
const GumboParser* parser) {
GumboVector* template_insertion_modes =
&parser->_parser_state->_template_insertion_modes;
if (template_insertion_modes->length == 0) {
return GUMBO_INSERTION_MODE_INITIAL;
}
return (GumboInsertionMode)
template_insertion_modes->data[(template_insertion_modes->length - 1)];
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#mathml-text-integration-point
static bool is_mathml_integration_point(const GumboNode* node) {
return node_tag_in_set(
node, (gumbo_tagset){TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN),
TAG_MATHML(MS), TAG_MATHML(MTEXT)});
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#html-integration-point
static bool is_html_integration_point(const GumboNode* node) {
return node_tag_in_set(node, (gumbo_tagset){TAG_SVG(FOREIGNOBJECT),
TAG_SVG(DESC), TAG_SVG(TITLE)}) ||
(node_qualified_tag_is(
node, GUMBO_NAMESPACE_MATHML, GUMBO_TAG_ANNOTATION_XML) &&
(attribute_matches(
&node->v.element.attributes, "encoding", "text/html") ||
attribute_matches(&node->v.element.attributes, "encoding",
"application/xhtml+xml")));
}
// This represents a place to insert a node, consisting of a target parent and a
// child index within that parent. If the node should be inserted at the end of
// the parent's child, index will be -1.
typedef struct {
GumboNode* target;
int index;
} InsertionLocation;
InsertionLocation get_appropriate_insertion_location(
GumboParser* parser, GumboNode* override_target) {
InsertionLocation retval = {override_target, -1};
if (retval.target == NULL) {
// No override target; default to the current node, but special-case the
// root node since get_current_node() assumes the stack of open elements is
// non-empty.
retval.target = parser->_output->root != NULL ? get_current_node(parser)
: get_document_node(parser);
}
if (!parser->_parser_state->_foster_parent_insertions ||
!node_tag_in_set(retval.target, (gumbo_tagset){TAG(TABLE), TAG(TBODY),
TAG(TFOOT), TAG(THEAD), TAG(TR)})) {
return retval;
}
// Foster-parenting case.
int last_template_index = -1;
int last_table_index = -1;
GumboVector* open_elements = &parser->_parser_state->_open_elements;
for (unsigned int i = 0; i < open_elements->length; ++i) {
if (node_html_tag_is(open_elements->data[i], GUMBO_TAG_TEMPLATE)) {
last_template_index = i;
}
if (node_html_tag_is(open_elements->data[i], GUMBO_TAG_TABLE)) {
last_table_index = i;
}
}
if (last_template_index != -1 &&
(last_table_index == -1 || last_template_index > last_table_index)) {
retval.target = open_elements->data[last_template_index];
return retval;
}
if (last_table_index == -1) {
retval.target = open_elements->data[0];
return retval;
}
GumboNode* last_table = open_elements->data[last_table_index];
if (last_table->parent != NULL) {
retval.target = last_table->parent;
retval.index = last_table->index_within_parent;
return retval;
}
retval.target = open_elements->data[last_table_index - 1];
return retval;
}
// Appends a node to the end of its parent, setting the "parent" and
// "index_within_parent" fields appropriately.
static void append_node(
GumboParser* parser, GumboNode* parent, GumboNode* node) {
assert(node->parent == NULL);
assert(node->index_within_parent == -1);
GumboVector* children;
if (parent->type == GUMBO_NODE_ELEMENT ||
parent->type == GUMBO_NODE_TEMPLATE) {
children = &parent->v.element.children;
} else {
assert(parent->type == GUMBO_NODE_DOCUMENT);
children = &parent->v.document.children;
}
node->parent = parent;
node->index_within_parent = children->length;
gumbo_vector_add(parser, (void*) node, children);
assert(node->index_within_parent < children->length);
}
// Inserts a node at the specified InsertionLocation, updating the
// "parent" and "index_within_parent" fields of it and all its siblings.
// If the index of the location is -1, this calls append_node.
static void insert_node(
GumboParser* parser, GumboNode* node, InsertionLocation location) {
assert(node->parent == NULL);
assert(node->index_within_parent == -1);
GumboNode* parent = location.target;
int index = location.index;
if (index != -1) {
GumboVector* children = NULL;
if (parent->type == GUMBO_NODE_ELEMENT ||
parent->type == GUMBO_NODE_TEMPLATE) {
children = &parent->v.element.children;
} else if (parent->type == GUMBO_NODE_DOCUMENT) {
children = &parent->v.document.children;
assert(children->length == 0);
} else {
assert(0);
}
assert(index >= 0);
assert((unsigned int) index < children->length);
node->parent = parent;
node->index_within_parent = index;
gumbo_vector_insert_at(parser, (void*) node, index, children);
assert(node->index_within_parent < children->length);
for (unsigned int i = index + 1; i < children->length; ++i) {
GumboNode* sibling = children->data[i];
sibling->index_within_parent = i;
assert(sibling->index_within_parent < children->length);
}
} else {
append_node(parser, parent, node);
}
}
static void maybe_flush_text_node_buffer(GumboParser* parser) {
GumboParserState* state = parser->_parser_state;
TextNodeBufferState* buffer_state = &state->_text_node;
if (buffer_state->_buffer.length == 0) {
return;
}
assert(buffer_state->_type == GUMBO_NODE_WHITESPACE ||
buffer_state->_type == GUMBO_NODE_TEXT ||
buffer_state->_type == GUMBO_NODE_CDATA);
GumboNode* text_node = create_node(parser, buffer_state->_type);
GumboText* text_node_data = &text_node->v.text;
text_node_data->text =
gumbo_string_buffer_to_string(parser, &buffer_state->_buffer);
text_node_data->original_text.data = buffer_state->_start_original_text;
text_node_data->original_text.length =
state->_current_token->original_text.data -
buffer_state->_start_original_text;
text_node_data->start_pos = buffer_state->_start_position;
gumbo_debug("Flushing text node buffer of %.*s.\n",
(int) buffer_state->_buffer.length, buffer_state->_buffer.data);
InsertionLocation location = get_appropriate_insertion_location(parser, NULL);
if (location.target->type == GUMBO_NODE_DOCUMENT) {
// The DOM does not allow Document nodes to have Text children, so per the
// spec, they are dropped on the floor.
destroy_node(parser, text_node);
} else {
insert_node(parser, text_node, location);
}
gumbo_string_buffer_clear(parser, &buffer_state->_buffer);
buffer_state->_type = GUMBO_NODE_WHITESPACE;
assert(buffer_state->_buffer.length == 0);
}
static void record_end_of_element(
GumboToken* current_token, GumboElement* element) {
element->end_pos = current_token->position;
element->original_end_tag = current_token->type == GUMBO_TOKEN_END_TAG
? current_token->original_text
: kGumboEmptyString;
}
static GumboNode* pop_current_node(GumboParser* parser) {
GumboParserState* state = parser->_parser_state;
maybe_flush_text_node_buffer(parser);
if (state->_open_elements.length > 0) {
assert(node_html_tag_is(state->_open_elements.data[0], GUMBO_TAG_HTML));
gumbo_debug("Popping %s node.\n",
gumbo_normalized_tagname(get_current_node(parser)->v.element.tag));
}
GumboNode* current_node = gumbo_vector_pop(parser, &state->_open_elements);
if (!current_node) {
assert(state->_open_elements.length == 0);
return NULL;
}
assert(current_node->type == GUMBO_NODE_ELEMENT ||
current_node->type == GUMBO_NODE_TEMPLATE);
bool is_closed_body_or_html_tag =
(node_html_tag_is(current_node, GUMBO_TAG_BODY) &&
state->_closed_body_tag) ||
(node_html_tag_is(current_node, GUMBO_TAG_HTML) &&
state->_closed_html_tag);
if ((state->_current_token->type != GUMBO_TOKEN_END_TAG ||
!node_html_tag_is(current_node, state->_current_token->v.end_tag)) &&
!is_closed_body_or_html_tag) {
current_node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;
}
if (!is_closed_body_or_html_tag) {
record_end_of_element(state->_current_token, ¤t_node->v.element);
}
return current_node;
}
static void append_comment_node(
GumboParser* parser, GumboNode* node, const GumboToken* token) {
maybe_flush_text_node_buffer(parser);
GumboNode* comment = create_node(parser, GUMBO_NODE_COMMENT);
comment->type = GUMBO_NODE_COMMENT;
comment->parse_flags = GUMBO_INSERTION_NORMAL;
comment->v.text.text = token->v.text;
comment->v.text.original_text = token->original_text;
comment->v.text.start_pos = token->position;
append_node(parser, node, comment);
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#clear-the-stack-back-to-a-table-row-context
static void clear_stack_to_table_row_context(GumboParser* parser) {
while (!node_tag_in_set(get_current_node(parser),
(gumbo_tagset){TAG(HTML), TAG(TR), TAG(TEMPLATE)})) {
pop_current_node(parser);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#clear-the-stack-back-to-a-table-context
static void clear_stack_to_table_context(GumboParser* parser) {
while (!node_tag_in_set(get_current_node(parser),
(gumbo_tagset){TAG(HTML), TAG(TABLE), TAG(TEMPLATE)})) {
pop_current_node(parser);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#clear-the-stack-back-to-a-table-body-context
void clear_stack_to_table_body_context(GumboParser* parser) {
while (!node_tag_in_set(get_current_node(parser),
(gumbo_tagset){TAG(HTML), TAG(TBODY), TAG(TFOOT), TAG(THEAD),
TAG(TEMPLATE)})) {
pop_current_node(parser);
}
}
// Creates a parser-inserted element in the HTML namespace and returns it.
static GumboNode* create_element(GumboParser* parser, GumboTag tag) {
GumboNode* node = create_node(parser, GUMBO_NODE_ELEMENT);
GumboElement* element = &node->v.element;
gumbo_vector_init(parser, 1, &element->children);
gumbo_vector_init(parser, 0, &element->attributes);
element->tag = tag;
element->tag_namespace = GUMBO_NAMESPACE_HTML;
element->original_tag = kGumboEmptyString;
element->original_end_tag = kGumboEmptyString;
element->start_pos = (parser->_parser_state->_current_token)
? parser->_parser_state->_current_token->position
: kGumboEmptySourcePosition;
element->end_pos = kGumboEmptySourcePosition;
return node;
}
// Constructs an element from the given start tag token.
static GumboNode* create_element_from_token(
GumboParser* parser, GumboToken* token, GumboNamespaceEnum tag_namespace) {
assert(token->type == GUMBO_TOKEN_START_TAG);
GumboTokenStartTag* start_tag = &token->v.start_tag;
GumboNodeType type = (tag_namespace == GUMBO_NAMESPACE_HTML &&
start_tag->tag == GUMBO_TAG_TEMPLATE)
? GUMBO_NODE_TEMPLATE
: GUMBO_NODE_ELEMENT;
GumboNode* node = create_node(parser, type);
GumboElement* element = &node->v.element;
gumbo_vector_init(parser, 1, &element->children);
element->attributes = start_tag->attributes;
element->tag = start_tag->tag;
element->tag_namespace = tag_namespace;
assert(token->original_text.length >= 2);
assert(token->original_text.data[0] == '<');
assert(token->original_text.data[token->original_text.length - 1] == '>');
element->original_tag = token->original_text;
element->start_pos = token->position;
element->original_end_tag = kGumboEmptyString;
element->end_pos = kGumboEmptySourcePosition;
// The element takes ownership of the attributes from the token, so any
// allocated-memory fields should be nulled out.
start_tag->attributes = kGumboEmptyVector;
return node;
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#insert-an-html-element
static void insert_element(GumboParser* parser, GumboNode* node,
bool is_reconstructing_formatting_elements) {
GumboParserState* state = parser->_parser_state;
// NOTE(jdtang): The text node buffer must always be flushed before inserting
// a node, otherwise we're handling nodes in a different order than the spec
// mandated. However, one clause of the spec (character tokens in the body)
// requires that we reconstruct the active formatting elements *before* adding
// the character, and reconstructing the active formatting elements may itself
// result in the insertion of new elements (which should be pushed onto the
// stack of open elements before the buffer is flushed). We solve this (for
// the time being, the spec has been rewritten for <template> and the new
// version may be simpler here) with a boolean flag to this method.
if (!is_reconstructing_formatting_elements) {
maybe_flush_text_node_buffer(parser);
}
InsertionLocation location = get_appropriate_insertion_location(parser, NULL);
insert_node(parser, node, location);
gumbo_vector_add(parser, (void*) node, &state->_open_elements);
}
// Convenience method that combines create_element_from_token and
// insert_element, inserting the generated element directly into the current
// node. Returns the node inserted.
static GumboNode* insert_element_from_token(
GumboParser* parser, GumboToken* token) {
GumboNode* element =
create_element_from_token(parser, token, GUMBO_NAMESPACE_HTML);
insert_element(parser, element, false);
gumbo_debug("Inserting <%s> element (@%x) from token.\n",
gumbo_normalized_tagname(element->v.element.tag), element);
return element;
}
// Convenience method that combines create_element and insert_element, inserting
// a parser-generated element of a specific tag type. Returns the node
// inserted.
static GumboNode* insert_element_of_tag_type(
GumboParser* parser, GumboTag tag, GumboParseFlags reason) {
GumboNode* element = create_element(parser, tag);
element->parse_flags |= GUMBO_INSERTION_BY_PARSER | reason;
insert_element(parser, element, false);
gumbo_debug("Inserting %s element (@%x) from tag type.\n",
gumbo_normalized_tagname(tag), element);
return element;
}
// Convenience method for creating foreign namespaced element. Returns the node
// inserted.
static GumboNode* insert_foreign_element(
GumboParser* parser, GumboToken* token, GumboNamespaceEnum tag_namespace) {
assert(token->type == GUMBO_TOKEN_START_TAG);
GumboNode* element = create_element_from_token(parser, token, tag_namespace);
insert_element(parser, element, false);
if (token_has_attribute(token, "xmlns") &&
!attribute_matches_case_sensitive(&token->v.start_tag.attributes, "xmlns",
kLegalXmlns[tag_namespace])) {
// TODO(jdtang): Since there're multiple possible error codes here, we
// eventually need reason codes to differentiate them.
parser_add_parse_error(parser, token);
}
if (token_has_attribute(token, "xmlns:xlink") &&
!attribute_matches_case_sensitive(&token->v.start_tag.attributes,
"xmlns:xlink", "http://www.w3.org/1999/xlink")) {
parser_add_parse_error(parser, token);
}
return element;
}
static void insert_text_token(GumboParser* parser, GumboToken* token) {
assert(token->type == GUMBO_TOKEN_WHITESPACE ||
token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_NULL || token->type == GUMBO_TOKEN_CDATA);
TextNodeBufferState* buffer_state = &parser->_parser_state->_text_node;
if (buffer_state->_buffer.length == 0) {
// Initialize position fields.
buffer_state->_start_original_text = token->original_text.data;
buffer_state->_start_position = token->position;
}
gumbo_string_buffer_append_codepoint(
parser, token->v.character, &buffer_state->_buffer);
if (token->type == GUMBO_TOKEN_CHARACTER) {
buffer_state->_type = GUMBO_NODE_TEXT;
} else if (token->type == GUMBO_TOKEN_CDATA) {
buffer_state->_type = GUMBO_NODE_CDATA;
}
gumbo_debug("Inserting text token '%c'.\n", token->v.character);
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#generic-rcdata-element-parsing-algorithm
static void run_generic_parsing_algorithm(
GumboParser* parser, GumboToken* token, GumboTokenizerEnum lexer_state) {
insert_element_from_token(parser, token);
gumbo_tokenizer_set_state(parser, lexer_state);
parser->_parser_state->_original_insertion_mode =
parser->_parser_state->_insertion_mode;
parser->_parser_state->_insertion_mode = GUMBO_INSERTION_MODE_TEXT;
}
static void acknowledge_self_closing_tag(GumboParser* parser) {
parser->_parser_state->_self_closing_flag_acknowledged = true;
}
// Returns true if there's an anchor tag in the list of active formatting
// elements, and fills in its index if so.
static bool find_last_anchor_index(GumboParser* parser, int* anchor_index) {
GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
for (int i = elements->length; --i >= 0;) {
GumboNode* node = elements->data[i];
if (node == &kActiveFormattingScopeMarker) {
return false;
}
if (node_html_tag_is(node, GUMBO_TAG_A)) {
*anchor_index = i;
return true;
}
}
return false;
}
// Counts the number of open formatting elements in the list of active
// formatting elements (after the last active scope marker) that have a specific
// tag. If this is > 0, then earliest_matching_index will be filled in with the
// index of the first such element.
static int count_formatting_elements_of_tag(GumboParser* parser,
const GumboNode* desired_node, int* earliest_matching_index) {
const GumboElement* desired_element = &desired_node->v.element;
GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
int num_identical_elements = 0;
for (int i = elements->length; --i >= 0;) {
GumboNode* node = elements->data[i];
if (node == &kActiveFormattingScopeMarker) {
break;
}
assert(node->type == GUMBO_NODE_ELEMENT);
if (node_qualified_tag_is(
node, desired_element->tag_namespace, desired_element->tag) &&
all_attributes_match(
&node->v.element.attributes, &desired_element->attributes)) {
num_identical_elements++;
*earliest_matching_index = i;
}
}
return num_identical_elements;
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#reconstruct-the-active-formatting-elements
static void add_formatting_element(GumboParser* parser, const GumboNode* node) {
assert(node == &kActiveFormattingScopeMarker ||
node->type == GUMBO_NODE_ELEMENT);
GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
if (node == &kActiveFormattingScopeMarker) {
gumbo_debug("Adding a scope marker.\n");
} else {
gumbo_debug("Adding a formatting element.\n");
}
// Hunt for identical elements.
int earliest_identical_element = elements->length;
int num_identical_elements = count_formatting_elements_of_tag(
parser, node, &earliest_identical_element);
// Noah's Ark clause: if there're at least 3, remove the earliest.
if (num_identical_elements >= 3) {
gumbo_debug("Noah's ark clause: removing element at %d.\n",
earliest_identical_element);
gumbo_vector_remove_at(parser, earliest_identical_element, elements);
}
gumbo_vector_add(parser, (void*) node, elements);
}
static bool is_open_element(GumboParser* parser, const GumboNode* node) {
GumboVector* open_elements = &parser->_parser_state->_open_elements;
for (unsigned int i = 0; i < open_elements->length; ++i) {
if (open_elements->data[i] == node) {
return true;
}
}
return false;
}
// Clones attributes, tags, etc. of a node, but does not copy the content. The
// clone shares no structure with the original node: all owned strings and
// values are fresh copies.
GumboNode* clone_node(
GumboParser* parser, GumboNode* node, GumboParseFlags reason) {
assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
GumboNode* new_node = gumbo_parser_allocate(parser, sizeof(GumboNode));
*new_node = *node;
new_node->parent = NULL;
new_node->index_within_parent = -1;
// Clear the GUMBO_INSERTION_IMPLICIT_END_TAG flag, as the cloned node may
// have a separate end tag.
new_node->parse_flags &= ~GUMBO_INSERTION_IMPLICIT_END_TAG;
new_node->parse_flags |= reason | GUMBO_INSERTION_BY_PARSER;
GumboElement* element = &new_node->v.element;
gumbo_vector_init(parser, 1, &element->children);
const GumboVector* old_attributes = &node->v.element.attributes;
gumbo_vector_init(parser, old_attributes->length, &element->attributes);
for (unsigned int i = 0; i < old_attributes->length; ++i) {
const GumboAttribute* old_attr = old_attributes->data[i];
GumboAttribute* attr =
gumbo_parser_allocate(parser, sizeof(GumboAttribute));
*attr = *old_attr;
attr->name = gumbo_copy_stringz(parser, old_attr->name);
attr->value = gumbo_copy_stringz(parser, old_attr->value);
gumbo_vector_add(parser, attr, &element->attributes);
}
return new_node;
}
// "Reconstruct active formatting elements" part of the spec.
// This implementation is based on the html5lib translation from the mess of
// GOTOs in the spec to reasonably structured programming.
// http://code.google.com/p/html5lib/source/browse/python/html5lib/treebuilders/_base.py
static void reconstruct_active_formatting_elements(GumboParser* parser) {
GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
// Step 1
if (elements->length == 0) {
return;
}
// Step 2 & 3
unsigned int i = elements->length - 1;
GumboNode* element = elements->data[i];
if (element == &kActiveFormattingScopeMarker ||
is_open_element(parser, element)) {
return;
}
// Step 6
do {
if (i == 0) {
// Step 4
i = -1; // Incremented to 0 below.
break;
}
// Step 5
element = elements->data[--i];
} while (element != &kActiveFormattingScopeMarker &&
!is_open_element(parser, element));
++i;
gumbo_debug("Reconstructing elements from %d on %s parent.\n", i,
gumbo_normalized_tagname(get_current_node(parser)->v.element.tag));
for (; i < elements->length; ++i) {
// Step 7 & 8.
assert(elements->length > 0);
assert(i < elements->length);
element = elements->data[i];
assert(element != &kActiveFormattingScopeMarker);
GumboNode* clone = clone_node(
parser, element, GUMBO_INSERTION_RECONSTRUCTED_FORMATTING_ELEMENT);
// Step 9.
InsertionLocation location =
get_appropriate_insertion_location(parser, NULL);
insert_node(parser, clone, location);
gumbo_vector_add(
parser, (void*) clone, &parser->_parser_state->_open_elements);
// Step 10.
elements->data[i] = clone;
gumbo_debug("Reconstructed %s element at %d.\n",
gumbo_normalized_tagname(clone->v.element.tag), i);
}
}
static void clear_active_formatting_elements(GumboParser* parser) {
GumboVector* elements = &parser->_parser_state->_active_formatting_elements;
int num_elements_cleared = 0;
const GumboNode* node;
do {
node = gumbo_vector_pop(parser, elements);
++num_elements_cleared;
} while (node && node != &kActiveFormattingScopeMarker);
gumbo_debug("Cleared %d elements from active formatting list.\n",
num_elements_cleared);
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#the-initial-insertion-mode
static GumboQuirksModeEnum compute_quirks_mode(
const GumboTokenDocType* doctype) {
if (doctype->force_quirks || strcmp(doctype->name, kDoctypeHtml.data) ||
is_in_static_list(
doctype->public_identifier, kQuirksModePublicIdPrefixes, false) ||
is_in_static_list(
doctype->public_identifier, kQuirksModePublicIdExactMatches, true) ||
is_in_static_list(
doctype->system_identifier, kQuirksModeSystemIdExactMatches, true) ||
(is_in_static_list(doctype->public_identifier,
kLimitedQuirksRequiresSystemIdPublicIdPrefixes, false) &&
!doctype->has_system_identifier)) {
return GUMBO_DOCTYPE_QUIRKS;
} else if (is_in_static_list(doctype->public_identifier,
kLimitedQuirksPublicIdPrefixes, false) ||
(is_in_static_list(doctype->public_identifier,
kLimitedQuirksRequiresSystemIdPublicIdPrefixes, false) &&
doctype->has_system_identifier)) {
return GUMBO_DOCTYPE_LIMITED_QUIRKS;
}
return GUMBO_DOCTYPE_NO_QUIRKS;
}
// The following functions are all defined by the "has an element in __ scope"
// sections of the HTML5 spec:
// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-the-specific-scope
// The basic idea behind them is that they check for an element of the given
// qualified name, contained within a scope formed by a set of other qualified
// names. For example, "has an element in list scope" looks for an element of
// the given qualified name within the nearest enclosing <ol> or <ul>, along
// with a bunch of generic element types that serve to "firewall" their content
// from the rest of the document. Note that because of the way the spec is
// written,
// all elements are expected to be in the HTML namespace
static bool has_an_element_in_specific_scope(GumboParser* parser,
int expected_size, const GumboTag* expected, bool negate,
const gumbo_tagset tags) {
GumboVector* open_elements = &parser->_parser_state->_open_elements;
for (int i = open_elements->length; --i >= 0;) {
const GumboNode* node = open_elements->data[i];
if (node->type != GUMBO_NODE_ELEMENT && node->type != GUMBO_NODE_TEMPLATE)
continue;
GumboTag node_tag = node->v.element.tag;
GumboNamespaceEnum node_ns = node->v.element.tag_namespace;
for (int j = 0; j < expected_size; ++j) {
if (node_tag == expected[j] && node_ns == GUMBO_NAMESPACE_HTML)
return true;
}
bool found = TAGSET_INCLUDES(tags, node_ns, node_tag);
if (negate != found) return false;
}
return false;
}
// Checks for the presence of an open element of the specified tag type.
static bool has_open_element(GumboParser* parser, GumboTag tag) {
return has_an_element_in_specific_scope(
parser, 1, &tag, false, (gumbo_tagset){TAG(HTML)});
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-scope
static bool has_an_element_in_scope(GumboParser* parser, GumboTag tag) {
return has_an_element_in_specific_scope(parser, 1, &tag, false,
(gumbo_tagset){TAG(APPLET), TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD),
TAG(TH), TAG(MARQUEE), TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI),
TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS), TAG_MATHML(MTEXT),
TAG_MATHML(ANNOTATION_XML), TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC),
TAG_SVG(TITLE)});
}
// Like "has an element in scope", but for the specific case of looking for a
// unique target node, not for any node with a given tag name. This duplicates
// much of the algorithm from has_an_element_in_specific_scope because the
// predicate is different when checking for an exact node, and it's easier &
// faster just to duplicate the code for this one case than to try and
// parameterize it.
static bool has_node_in_scope(GumboParser* parser, const GumboNode* node) {
GumboVector* open_elements = &parser->_parser_state->_open_elements;
for (int i = open_elements->length; --i >= 0;) {
const GumboNode* current = open_elements->data[i];
if (current == node) {
return true;
}
if (current->type != GUMBO_NODE_ELEMENT &&
current->type != GUMBO_NODE_TEMPLATE) {
continue;
}
if (node_tag_in_set(current,
(gumbo_tagset){TAG(APPLET), TAG(CAPTION), TAG(HTML), TAG(TABLE),
TAG(TD), TAG(TH), TAG(MARQUEE), TAG(OBJECT), TAG(TEMPLATE),
TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS),
TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC), TAG_SVG(TITLE)})) {
return false;
}
}
assert(false);
return false;
}
// Like has_an_element_in_scope, but restricts the expected qualified name to a
// range of possible qualified names instead of just a single one.
static bool has_an_element_in_scope_with_tagname(
GumboParser* parser, int expected_len, const GumboTag expected[]) {
return has_an_element_in_specific_scope(parser, expected_len, expected, false,
(gumbo_tagset){TAG(APPLET), TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD),
TAG(TH), TAG(MARQUEE), TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI),
TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS), TAG_MATHML(MTEXT),
TAG_MATHML(ANNOTATION_XML), TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC),
TAG_SVG(TITLE)});
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-list-item-scope
static bool has_an_element_in_list_scope(GumboParser* parser, GumboTag tag) {
return has_an_element_in_specific_scope(parser, 1, &tag, false,
(gumbo_tagset){TAG(APPLET), TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD),
TAG(TH), TAG(MARQUEE), TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI),
TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS), TAG_MATHML(MTEXT),
TAG_MATHML(ANNOTATION_XML), TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC),
TAG_SVG(TITLE), TAG(OL), TAG(UL)});
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-button-scope
static bool has_an_element_in_button_scope(GumboParser* parser, GumboTag tag) {
return has_an_element_in_specific_scope(parser, 1, &tag, false,
(gumbo_tagset){TAG(APPLET), TAG(CAPTION), TAG(HTML), TAG(TABLE), TAG(TD),
TAG(TH), TAG(MARQUEE), TAG(OBJECT), TAG(TEMPLATE), TAG_MATHML(MI),
TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS), TAG_MATHML(MTEXT),
TAG_MATHML(ANNOTATION_XML), TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC),
TAG_SVG(TITLE), TAG(BUTTON)});
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-table-scope
static bool has_an_element_in_table_scope(GumboParser* parser, GumboTag tag) {
return has_an_element_in_specific_scope(parser, 1, &tag, false,
(gumbo_tagset){TAG(HTML), TAG(TABLE), TAG(TEMPLATE)});
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#has-an-element-in-select-scope
static bool has_an_element_in_select_scope(GumboParser* parser, GumboTag tag) {
return has_an_element_in_specific_scope(
parser, 1, &tag, true, (gumbo_tagset){TAG(OPTGROUP), TAG(OPTION)});
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#generate-implied-end-tags
// "exception" is the "element to exclude from the process" listed in the spec.
// Pass GUMBO_TAG_LAST to not exclude any of them.
static void generate_implied_end_tags(GumboParser* parser, GumboTag exception) {
for (; node_tag_in_set(get_current_node(parser),
(gumbo_tagset){TAG(DD), TAG(DT), TAG(LI), TAG(OPTION),
TAG(OPTGROUP), TAG(P), TAG(RP), TAG(RB), TAG(RT), TAG(RTC)}) &&
!node_html_tag_is(get_current_node(parser), exception);
pop_current_node(parser))
;
}
// This is the "generate all implied end tags thoroughly" clause of the spec.
// https://html.spec.whatwg.org/multipage/syntax.html#closing-elements-that-have-implied-end-tags
static void generate_all_implied_end_tags_thoroughly(GumboParser* parser) {
for (
; node_tag_in_set(get_current_node(parser),
(gumbo_tagset){TAG(CAPTION), TAG(COLGROUP), TAG(DD), TAG(DT), TAG(LI),
TAG(OPTION), TAG(OPTGROUP), TAG(P), TAG(RP), TAG(RT), TAG(RTC),
TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(HEAD), TAG(TR)});
pop_current_node(parser))
;
}
// This factors out the clauses relating to "act as if an end tag token with tag
// name "table" had been seen. Returns true if there's a table element in table
// scope which was successfully closed, false if not and the token should be
// ignored. Does not add parse errors; callers should handle that.
static bool close_table(GumboParser* parser) {
if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TABLE)) {
return false;
}
GumboNode* node = pop_current_node(parser);
while (!node_html_tag_is(node, GUMBO_TAG_TABLE)) {
node = pop_current_node(parser);
}
reset_insertion_mode_appropriately(parser);
return true;
}
// This factors out the clauses relating to "act as if an end tag token with tag
// name `cell_tag` had been seen".
static bool close_table_cell(
GumboParser* parser, const GumboToken* token, GumboTag cell_tag) {
bool result = true;
generate_implied_end_tags(parser, GUMBO_TAG_LAST);
const GumboNode* node = get_current_node(parser);
if (!node_html_tag_is(node, cell_tag)) {
parser_add_parse_error(parser, token);
result = false;
}
do {
node = pop_current_node(parser);
} while (!node_html_tag_is(node, cell_tag));
clear_active_formatting_elements(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
return result;
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#close-the-cell
// This holds the logic to determine whether we should close a <td> or a <th>.
static bool close_current_cell(GumboParser* parser, const GumboToken* token) {
if (has_an_element_in_table_scope(parser, GUMBO_TAG_TD)) {
assert(!has_an_element_in_table_scope(parser, GUMBO_TAG_TH));
return close_table_cell(parser, token, GUMBO_TAG_TD);
} else {
assert(has_an_element_in_table_scope(parser, GUMBO_TAG_TH));
return close_table_cell(parser, token, GUMBO_TAG_TH);
}
}
// This factors out the "act as if an end tag of tag name 'select' had been
// seen" clause of the spec, since it's referenced in several places. It pops
// all nodes from the stack until the current <select> has been closed, then
// resets the insertion mode appropriately.
static void close_current_select(GumboParser* parser) {
GumboNode* node = pop_current_node(parser);
while (!node_html_tag_is(node, GUMBO_TAG_SELECT)) {
node = pop_current_node(parser);
}
reset_insertion_mode_appropriately(parser);
}
// The list of nodes in the "special" category:
// http://www.whatwg.org/specs/web-apps/current-work/complete/parsing.html#special
static bool is_special_node(const GumboNode* node) {
assert(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE);
return node_tag_in_set(node,
(gumbo_tagset){TAG(ADDRESS), TAG(APPLET), TAG(AREA), TAG(ARTICLE),
TAG(ASIDE), TAG(BASE), TAG(BASEFONT), TAG(BGSOUND), TAG(BLOCKQUOTE),
TAG(BODY), TAG(BR), TAG(BUTTON), TAG(CAPTION), TAG(CENTER), TAG(COL),
TAG(COLGROUP), TAG(MENUITEM), TAG(DD), TAG(DETAILS), TAG(DIR),
TAG(DIV), TAG(DL), TAG(DT), TAG(EMBED), TAG(FIELDSET),
TAG(FIGCAPTION), TAG(FIGURE), TAG(FOOTER), TAG(FORM), TAG(FRAME),
TAG(FRAMESET), TAG(H1), TAG(H2), TAG(H3), TAG(H4), TAG(H5), TAG(H6),
TAG(HEAD), TAG(HEADER), TAG(HGROUP), TAG(HR), TAG(HTML), TAG(IFRAME),
TAG(IMG), TAG(INPUT), TAG(ISINDEX), TAG(LI), TAG(LINK), TAG(LISTING),
TAG(MARQUEE), TAG(MENU), TAG(META), TAG(NAV), TAG(NOEMBED),
TAG(NOFRAMES), TAG(NOSCRIPT), TAG(OBJECT), TAG(OL), TAG(P),
TAG(PARAM), TAG(PLAINTEXT), TAG(PRE), TAG(SCRIPT), TAG(SECTION),
TAG(SELECT), TAG(STYLE), TAG(SUMMARY), TAG(TABLE), TAG(TBODY),
TAG(TD), TAG(TEMPLATE), TAG(TEXTAREA), TAG(TFOOT), TAG(TH),
TAG(THEAD), TAG(TITLE), TAG(TR), TAG(UL), TAG(WBR), TAG(XMP),
TAG_MATHML(MI), TAG_MATHML(MO), TAG_MATHML(MN), TAG_MATHML(MS),
TAG_MATHML(MTEXT), TAG_MATHML(ANNOTATION_XML),
TAG_SVG(FOREIGNOBJECT), TAG_SVG(DESC)});
}
// Implicitly closes currently open elements until it reaches an element with
// the
// specified qualified name. If the elements closed are in the set handled by
// generate_implied_end_tags, this is normal operation and this function returns
// true. Otherwise, a parse error is recorded and this function returns false.
static bool implicitly_close_tags(GumboParser* parser, GumboToken* token,
GumboNamespaceEnum target_ns, GumboTag target) {
bool result = true;
generate_implied_end_tags(parser, target);
if (!node_qualified_tag_is(get_current_node(parser), target_ns, target)) {
parser_add_parse_error(parser, token);
while (
!node_qualified_tag_is(get_current_node(parser), target_ns, target)) {
pop_current_node(parser);
}
result = false;
}
assert(node_qualified_tag_is(get_current_node(parser), target_ns, target));
pop_current_node(parser);
return result;
}
// If the stack of open elements has a <p> tag in button scope, this acts as if
// a </p> tag was encountered, implicitly closing tags. Returns false if a
// parse error occurs. This is a convenience function because this particular
// clause appears several times in the spec.
static bool maybe_implicitly_close_p_tag(
GumboParser* parser, GumboToken* token) {
if (has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
return implicitly_close_tags(
parser, token, GUMBO_NAMESPACE_HTML, GUMBO_TAG_P);
}
return true;
}
// Convenience function to encapsulate the logic for closing <li> or <dd>/<dt>
// tags. Pass true to is_li for handling <li> tags, false for <dd> and <dt>.
static void maybe_implicitly_close_list_tag(
GumboParser* parser, GumboToken* token, bool is_li) {
GumboParserState* state = parser->_parser_state;
state->_frameset_ok = false;
for (int i = state->_open_elements.length; --i >= 0;) {
const GumboNode* node = state->_open_elements.data[i];
bool is_list_tag =
is_li ? node_html_tag_is(node, GUMBO_TAG_LI)
: node_tag_in_set(node, (gumbo_tagset){TAG(DD), TAG(DT)});
if (is_list_tag) {
implicitly_close_tags(
parser, token, node->v.element.tag_namespace, node->v.element.tag);
return;
}
if (is_special_node(node) &&
!node_tag_in_set(
node, (gumbo_tagset){TAG(ADDRESS), TAG(DIV), TAG(P)})) {
return;
}
}
}
static void merge_attributes(
GumboParser* parser, GumboToken* token, GumboNode* node) {
assert(token->type == GUMBO_TOKEN_START_TAG);
assert(node->type == GUMBO_NODE_ELEMENT);
const GumboVector* token_attr = &token->v.start_tag.attributes;
GumboVector* node_attr = &node->v.element.attributes;
for (unsigned int i = 0; i < token_attr->length; ++i) {
GumboAttribute* attr = token_attr->data[i];
if (!gumbo_get_attribute(node_attr, attr->name)) {
// Ownership of the attribute is transferred by this gumbo_vector_add,
// so it has to be nulled out of the original token so it doesn't get
// double-deleted.
gumbo_vector_add(parser, attr, node_attr);
token_attr->data[i] = NULL;
}
}
// When attributes are merged, it means the token has been ignored and merged
// with another token, so we need to free its memory. The attributes that are
// transferred need to be nulled-out in the vector above so that they aren't
// double-deleted.
gumbo_token_destroy(parser, token);
#ifndef NDEBUG
// Mark this sentinel so the assertion in the main loop knows it's been
// destroyed.
token->v.start_tag.attributes = kGumboEmptyVector;
#endif
}
const char* gumbo_normalize_svg_tagname(const GumboStringPiece* tag) {
for (size_t i = 0; i < sizeof(kSvgTagReplacements) / sizeof(ReplacementEntry);
++i) {
const ReplacementEntry* entry = &kSvgTagReplacements[i];
if (gumbo_string_equals_ignore_case(tag, &entry->from)) {
return entry->to.data;
}
}
return NULL;
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adjust-foreign-attributes
// This destructively modifies any matching attributes on the token and sets the
// namespace appropriately.
static void adjust_foreign_attributes(GumboParser* parser, GumboToken* token) {
assert(token->type == GUMBO_TOKEN_START_TAG);
const GumboVector* attributes = &token->v.start_tag.attributes;
for (size_t i = 0; i < sizeof(kForeignAttributeReplacements) /
sizeof(NamespacedAttributeReplacement);
++i) {
const NamespacedAttributeReplacement* entry =
&kForeignAttributeReplacements[i];
GumboAttribute* attr = gumbo_get_attribute(attributes, entry->from);
if (!attr) {
continue;
}
gumbo_parser_deallocate(parser, (void*) attr->name);
attr->attr_namespace = entry->attr_namespace;
attr->name = gumbo_copy_stringz(parser, entry->local_name);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#adjust-svg-attributes
// This destructively modifies any matching attributes on the token.
static void adjust_svg_attributes(GumboParser* parser, GumboToken* token) {
assert(token->type == GUMBO_TOKEN_START_TAG);
const GumboVector* attributes = &token->v.start_tag.attributes;
for (size_t i = 0;
i < sizeof(kSvgAttributeReplacements) / sizeof(ReplacementEntry); ++i) {
const ReplacementEntry* entry = &kSvgAttributeReplacements[i];
GumboAttribute* attr = gumbo_get_attribute(attributes, entry->from.data);
if (!attr) {
continue;
}
gumbo_parser_deallocate(parser, (void*) attr->name);
attr->name = gumbo_copy_stringz(parser, entry->to.data);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#adjust-mathml-attributes
// Note that this may destructively modify the token with the new attribute
// value.
static void adjust_mathml_attributes(GumboParser* parser, GumboToken* token) {
assert(token->type == GUMBO_TOKEN_START_TAG);
GumboAttribute* attr =
gumbo_get_attribute(&token->v.start_tag.attributes, "definitionurl");
if (!attr) {
return;
}
gumbo_parser_deallocate(parser, (void*) attr->name);
attr->name = gumbo_copy_stringz(parser, "definitionURL");
}
static bool doctype_matches(const GumboTokenDocType* doctype,
const GumboStringPiece* public_id, const GumboStringPiece* system_id,
bool allow_missing_system_id) {
return !strcmp(doctype->public_identifier, public_id->data) &&
(allow_missing_system_id || doctype->has_system_identifier) &&
!strcmp(doctype->system_identifier, system_id->data);
}
static bool maybe_add_doctype_error(
GumboParser* parser, const GumboToken* token) {
const GumboTokenDocType* doctype = &token->v.doc_type;
bool html_doctype = !strcmp(doctype->name, kDoctypeHtml.data);
if ((!html_doctype || doctype->has_public_identifier ||
(doctype->has_system_identifier &&
!strcmp(
doctype->system_identifier, kSystemIdLegacyCompat.data))) &&
!(html_doctype && (doctype_matches(doctype, &kPublicIdHtml4_0,
&kSystemIdRecHtml4_0, true) ||
doctype_matches(doctype, &kPublicIdHtml4_01,
&kSystemIdHtml4, true) ||
doctype_matches(doctype, &kPublicIdXhtml1_0,
&kSystemIdXhtmlStrict1_1, false) ||
doctype_matches(doctype, &kPublicIdXhtml1_1,
&kSystemIdXhtml1_1, false)))) {
parser_add_parse_error(parser, token);
return false;
}
return true;
}
static void remove_from_parent(GumboParser* parser, GumboNode* node) {
if (!node->parent) {
// The node may not have a parent if, for example, it is a newly-cloned copy
// of an active formatting element. DOM manipulations continue with the
// orphaned fragment of the DOM tree until it's appended/foster-parented to
// the common ancestor at the end of the adoption agency algorithm.
return;
}
assert(node->parent->type == GUMBO_NODE_ELEMENT);
GumboVector* children = &node->parent->v.element.children;
int index = gumbo_vector_index_of(children, node);
assert(index != -1);
gumbo_vector_remove_at(parser, index, children);
node->parent = NULL;
node->index_within_parent = -1;
for (unsigned int i = index; i < children->length; ++i) {
GumboNode* child = children->data[i];
child->index_within_parent = i;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#an-introduction-to-error-handling-and-strange-cases-in-the-parser
// Also described in the "in body" handling for end formatting tags.
static bool adoption_agency_algorithm(
GumboParser* parser, GumboToken* token, GumboTag subject) {
GumboParserState* state = parser->_parser_state;
gumbo_debug("Entering adoption agency algorithm.\n");
// Step 1.
GumboNode* current_node = get_current_node(parser);
if (current_node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML &&
current_node->v.element.tag == subject &&
gumbo_vector_index_of(
&state->_active_formatting_elements, current_node) == -1) {
pop_current_node(parser);
return false;
}
// Steps 2-4 & 20:
for (unsigned int i = 0; i < 8; ++i) {
// Step 5.
GumboNode* formatting_node = NULL;
int formatting_node_in_open_elements = -1;
for (int j = state->_active_formatting_elements.length; --j >= 0;) {
GumboNode* current_node = state->_active_formatting_elements.data[j];
if (current_node == &kActiveFormattingScopeMarker) {
gumbo_debug("Broke on scope marker; aborting.\n");
// Last scope marker; abort the algorithm.
return false;
}
if (node_html_tag_is(current_node, subject)) {
// Found it.
formatting_node = current_node;
formatting_node_in_open_elements =
gumbo_vector_index_of(&state->_open_elements, formatting_node);
gumbo_debug("Formatting element of tag %s at %d.\n",
gumbo_normalized_tagname(subject),
formatting_node_in_open_elements);
break;
}
}
if (!formatting_node) {
// No matching tag; not a parse error outright, but fall through to the
// "any other end tag" clause (which may potentially add a parse error,
// but not always).
gumbo_debug("No active formatting elements; aborting.\n");
return false;
}
// Step 6
if (formatting_node_in_open_elements == -1) {
gumbo_debug("Formatting node not on stack of open elements.\n");
parser_add_parse_error(parser, token);
gumbo_vector_remove(
parser, formatting_node, &state->_active_formatting_elements);
return false;
}
// Step 7
if (!has_an_element_in_scope(parser, formatting_node->v.element.tag)) {
parser_add_parse_error(parser, token);
gumbo_debug("Element not in scope.\n");
return false;
}
// Step 8
if (formatting_node != get_current_node(parser)) {
parser_add_parse_error(parser, token); // But continue onwards.
}
assert(formatting_node);
assert(!node_html_tag_is(formatting_node, GUMBO_TAG_HTML));
assert(!node_html_tag_is(formatting_node, GUMBO_TAG_BODY));
// Step 9 & 10
GumboNode* furthest_block = NULL;
for (unsigned int j = formatting_node_in_open_elements;
j < state->_open_elements.length; ++j) {
assert(j > 0);
GumboNode* current = state->_open_elements.data[j];
if (is_special_node(current)) {
// Step 9.
furthest_block = current;
break;
}
}
if (!furthest_block) {
// Step 10.
while (get_current_node(parser) != formatting_node) {
pop_current_node(parser);
}
// And the formatting element itself.
pop_current_node(parser);
gumbo_vector_remove(
parser, formatting_node, &state->_active_formatting_elements);
return false;
}
assert(!node_html_tag_is(furthest_block, GUMBO_TAG_HTML));
assert(furthest_block);
// Step 11.
// Elements may be moved and reparented by this algorithm, so
// common_ancestor is not necessarily the same as formatting_node->parent.
GumboNode* common_ancestor =
state->_open_elements.data[gumbo_vector_index_of(&state->_open_elements,
formatting_node) -
1];
gumbo_debug("Common ancestor tag = %s, furthest block tag = %s.\n",
gumbo_normalized_tagname(common_ancestor->v.element.tag),
gumbo_normalized_tagname(furthest_block->v.element.tag));
// Step 12.
int bookmark = gumbo_vector_index_of(
&state->_active_formatting_elements, formatting_node) +
1;
gumbo_debug("Bookmark at %d.\n", bookmark);
// Step 13.
GumboNode* node = furthest_block;
GumboNode* last_node = furthest_block;
// Must be stored explicitly, in case node is removed from the stack of open
// elements, to handle step 9.4.
int saved_node_index = gumbo_vector_index_of(&state->_open_elements, node);
assert(saved_node_index > 0);
// Step 13.1.
for (int j = 0;;) {
// Step 13.2.
++j;
// Step 13.3.
int node_index = gumbo_vector_index_of(&state->_open_elements, node);
gumbo_debug(
"Current index: %d, last index: %d.\n", node_index, saved_node_index);
if (node_index == -1) {
node_index = saved_node_index;
}
saved_node_index = --node_index;
assert(node_index > 0);
assert((unsigned int) node_index < state->_open_elements.capacity);
node = state->_open_elements.data[node_index];
assert(node->parent);
if (node == formatting_node) {
// Step 13.4.
break;
}
int formatting_index =
gumbo_vector_index_of(&state->_active_formatting_elements, node);
if (j > 3 && formatting_index != -1) {
// Step 13.5.
gumbo_debug("Removing formatting element at %d.\n", formatting_index);
gumbo_vector_remove_at(
parser, formatting_index, &state->_active_formatting_elements);
// Removing the element shifts all indices over by one, so we may need
// to move the bookmark.
if (formatting_index < bookmark) {
--bookmark;
gumbo_debug("Moving bookmark to %d.\n", bookmark);
}
continue;
}
if (formatting_index == -1) {
// Step 13.6.
gumbo_vector_remove_at(parser, node_index, &state->_open_elements);
continue;
}
// Step 13.7.
// "common ancestor as the intended parent" doesn't actually mean insert
// it into the common ancestor; that happens below.
node = clone_node(parser, node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
assert(formatting_index >= 0);
state->_active_formatting_elements.data[formatting_index] = node;
assert(node_index >= 0);
state->_open_elements.data[node_index] = node;
// Step 13.8.
if (last_node == furthest_block) {
bookmark = formatting_index + 1;
gumbo_debug("Bookmark moved to %d.\n", bookmark);
assert((unsigned int) bookmark <= state->_active_formatting_elements.length);
}
// Step 13.9.
last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
remove_from_parent(parser, last_node);
append_node(parser, node, last_node);
// Step 13.10.
last_node = node;
} // Step 13.11.
// Step 14.
gumbo_debug("Removing %s node from parent ",
gumbo_normalized_tagname(last_node->v.element.tag));
remove_from_parent(parser, last_node);
last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
InsertionLocation location =
get_appropriate_insertion_location(parser, common_ancestor);
gumbo_debug("and inserting it into %s.\n",
gumbo_normalized_tagname(location.target->v.element.tag));
insert_node(parser, last_node, location);
// Step 15.
GumboNode* new_formatting_node = clone_node(
parser, formatting_node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
formatting_node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;
// Step 16. Instead of appending nodes one-by-one, we swap the children
// vector of furthest_block with the empty children of new_formatting_node,
// reducing memory traffic and allocations. We still have to reset their
// parent pointers, though.
GumboVector temp = new_formatting_node->v.element.children;
new_formatting_node->v.element.children =
furthest_block->v.element.children;
furthest_block->v.element.children = temp;
temp = new_formatting_node->v.element.children;
for (unsigned int i = 0; i < temp.length; ++i) {
GumboNode* child = temp.data[i];
child->parent = new_formatting_node;
}
// Step 17.
append_node(parser, furthest_block, new_formatting_node);
// Step 18.
// If the formatting node was before the bookmark, it may shift over all
// indices after it, so we need to explicitly find the index and possibly
// adjust the bookmark.
int formatting_node_index = gumbo_vector_index_of(
&state->_active_formatting_elements, formatting_node);
assert(formatting_node_index != -1);
if (formatting_node_index < bookmark) {
gumbo_debug(
"Formatting node at %d is before bookmark at %d; decrementing.\n",
formatting_node_index, bookmark);
--bookmark;
}
gumbo_vector_remove_at(
parser, formatting_node_index, &state->_active_formatting_elements);
assert(bookmark >= 0);
assert((unsigned int) bookmark <= state->_active_formatting_elements.length);
gumbo_vector_insert_at(parser, new_formatting_node, bookmark,
&state->_active_formatting_elements);
// Step 19.
gumbo_vector_remove(parser, formatting_node, &state->_open_elements);
int insert_at =
gumbo_vector_index_of(&state->_open_elements, furthest_block) + 1;
assert(insert_at >= 0);
assert((unsigned int) insert_at <= state->_open_elements.length);
gumbo_vector_insert_at(
parser, new_formatting_node, insert_at, &state->_open_elements);
} // Step 20.
return true;
}
// This is here to clean up memory when the spec says "Ignore current token."
static void ignore_token(GumboParser* parser) {
GumboToken* token = parser->_parser_state->_current_token;
// Ownership of the token's internal buffers are normally transferred to the
// element, but if no element is emitted (as happens in non-verbatim-mode
// when a token is ignored), we need to free it here to prevent a memory
// leak.
gumbo_token_destroy(parser, token);
#ifndef NDEBUG
if (token->type == GUMBO_TOKEN_START_TAG) {
// Mark this sentinel so the assertion in the main loop knows it's been
// destroyed.
token->v.start_tag.attributes = kGumboEmptyVector;
}
#endif
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/the-end.html
static void finish_parsing(GumboParser* parser) {
gumbo_debug("Finishing parsing");
maybe_flush_text_node_buffer(parser);
GumboParserState* state = parser->_parser_state;
for (GumboNode* node = pop_current_node(parser); node;
node = pop_current_node(parser)) {
if ((node_html_tag_is(node, GUMBO_TAG_BODY) && state->_closed_body_tag) ||
(node_html_tag_is(node, GUMBO_TAG_HTML) && state->_closed_html_tag)) {
continue;
}
node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;
}
while (pop_current_node(parser))
; // Pop them all.
}
static bool handle_initial(GumboParser* parser, GumboToken* token) {
GumboDocument* document = &get_document_node(parser)->v.document;
if (token->type == GUMBO_TOKEN_WHITESPACE) {
ignore_token(parser);
return true;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_document_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
document->has_doctype = true;
document->name = token->v.doc_type.name;
document->public_identifier = token->v.doc_type.public_identifier;
document->system_identifier = token->v.doc_type.system_identifier;
document->doc_type_quirks_mode = compute_quirks_mode(&token->v.doc_type);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HTML);
return maybe_add_doctype_error(parser, token);
}
parser_add_parse_error(parser, token);
document->doc_type_quirks_mode = GUMBO_DOCTYPE_QUIRKS;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HTML);
parser->_parser_state->_reprocess_current_token = true;
return true;
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#the-before-html-insertion-mode
static bool handle_before_html(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_document_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_WHITESPACE) {
ignore_token(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
GumboNode* html_node = insert_element_from_token(parser, token);
parser->_output->root = html_node;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
return true;
} else if (token->type == GUMBO_TOKEN_END_TAG &&
!tag_in(token, false,
(gumbo_tagset){TAG(HEAD), TAG(BODY), TAG(HTML), TAG(BR)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
GumboNode* html_node = insert_element_of_tag_type(
parser, GUMBO_TAG_HTML, GUMBO_INSERTION_IMPLIED);
assert(html_node);
parser->_output->root = html_node;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
parser->_parser_state->_reprocess_current_token = true;
return true;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#the-before-head-insertion-mode
static bool handle_before_head(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_WHITESPACE) {
ignore_token(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD)) {
GumboNode* node = insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
parser->_parser_state->_head_element = node;
return true;
} else if (token->type == GUMBO_TOKEN_END_TAG &&
!tag_in(token, false,
(gumbo_tagset){TAG(HEAD), TAG(BODY), TAG(HTML), TAG(BR)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
GumboNode* node = insert_element_of_tag_type(
parser, GUMBO_TAG_HEAD, GUMBO_INSERTION_IMPLIED);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
parser->_parser_state->_head_element = node;
parser->_parser_state->_reprocess_current_token = true;
return true;
}
}
// Forward declarations because of mutual dependencies.
static bool handle_token(GumboParser* parser, GumboToken* token);
static bool handle_in_body(GumboParser* parser, GumboToken* token);
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inhead
static bool handle_in_head(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(BASE), TAG(BASEFONT), TAG(BGSOUND),
TAG(MENUITEM), TAG(LINK)})) {
insert_element_from_token(parser, token);
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_META)) {
insert_element_from_token(parser, token);
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
// NOTE(jdtang): Gumbo handles only UTF-8, so the encoding clause of the
// spec doesn't apply. If clients want to handle meta-tag re-encoding, they
// should specifically look for that string in the document and re-encode it
// before passing to Gumbo.
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_TITLE)) {
run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RCDATA);
return true;
} else if (tag_in(
token, kStartTag, (gumbo_tagset){TAG(NOFRAMES), TAG(STYLE)})) {
run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_NOSCRIPT)) {
insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD_NOSCRIPT);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_SCRIPT)) {
run_generic_parsing_algorithm(parser, token, GUMBO_LEX_SCRIPT);
return true;
} else if (tag_is(token, kEndTag, GUMBO_TAG_HEAD)) {
GumboNode* head = pop_current_node(parser);
AVOID_UNUSED_VARIABLE_WARNING(head);
assert(node_html_tag_is(head, GUMBO_TAG_HEAD));
set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
return true;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(BODY), TAG(HTML), TAG(BR)})) {
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
parser->_parser_state->_reprocess_current_token = true;
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE)) {
insert_element_from_token(parser, token);
add_formatting_element(parser, &kActiveFormattingScopeMarker);
parser->_parser_state->_frameset_ok = false;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
return true;
} else if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
generate_all_implied_end_tags_thoroughly(parser);
bool success = true;
if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_TEMPLATE)) {
parser_add_parse_error(parser, token);
success = false;
}
while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_TEMPLATE))
;
clear_active_formatting_elements(parser);
pop_template_insertion_mode(parser);
reset_insertion_mode_appropriately(parser);
return success;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD) ||
(token->type == GUMBO_TOKEN_END_TAG)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
parser->_parser_state->_reprocess_current_token = true;
return true;
}
return true;
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inheadnoscript
static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (tag_is(token, kEndTag, GUMBO_TAG_NOSCRIPT)) {
const GumboNode* node = pop_current_node(parser);
assert(node_html_tag_is(node, GUMBO_TAG_NOSCRIPT));
AVOID_UNUSED_VARIABLE_WARNING(node);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
return true;
} else if (token->type == GUMBO_TOKEN_WHITESPACE ||
token->type == GUMBO_TOKEN_COMMENT ||
tag_in(token, kStartTag,
(gumbo_tagset){TAG(BASEFONT), TAG(BGSOUND), TAG(LINK),
TAG(META), TAG(NOFRAMES), TAG(STYLE)})) {
return handle_in_head(parser, token);
} else if (tag_in(
token, kStartTag, (gumbo_tagset){TAG(HEAD), TAG(NOSCRIPT)}) ||
(token->type == GUMBO_TOKEN_END_TAG &&
!tag_is(token, kEndTag, GUMBO_TAG_BR))) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
parser_add_parse_error(parser, token);
const GumboNode* node = pop_current_node(parser);
assert(node_html_tag_is(node, GUMBO_TAG_NOSCRIPT));
AVOID_UNUSED_VARIABLE_WARNING(node);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
parser->_parser_state->_reprocess_current_token = true;
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#the-after-head-insertion-mode
static bool handle_after_head(GumboParser* parser, GumboToken* token) {
GumboParserState* state = parser->_parser_state;
if (token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
insert_element_from_token(parser, token);
state->_frameset_ok = false;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_FRAMESET);
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(BASE), TAG(BASEFONT), TAG(BGSOUND),
TAG(LINK), TAG(META), TAG(NOFRAMES), TAG(SCRIPT),
TAG(STYLE), TAG(TEMPLATE), TAG(TITLE)})) {
parser_add_parse_error(parser, token);
assert(state->_head_element != NULL);
// This must be flushed before we push the head element on, as there may be
// pending character tokens that should be attached to the root.
maybe_flush_text_node_buffer(parser);
gumbo_vector_add(parser, state->_head_element, &state->_open_elements);
bool result = handle_in_head(parser, token);
gumbo_vector_remove(parser, state->_head_element, &state->_open_elements);
return result;
} else if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
return handle_in_head(parser, token);
} else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD) ||
(token->type == GUMBO_TOKEN_END_TAG &&
!tag_in(token, kEndTag,
(gumbo_tagset){TAG(BODY), TAG(HTML), TAG(BR)}))) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
insert_element_of_tag_type(parser, GUMBO_TAG_BODY, GUMBO_INSERTION_IMPLIED);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
state->_reprocess_current_token = true;
return true;
}
}
static void destroy_node(GumboParser* parser, GumboNode* node) {
switch (node->type) {
case GUMBO_NODE_DOCUMENT: {
GumboDocument* doc = &node->v.document;
for (unsigned int i = 0; i < doc->children.length; ++i) {
destroy_node(parser, doc->children.data[i]);
}
gumbo_parser_deallocate(parser, (void*) doc->children.data);
gumbo_parser_deallocate(parser, (void*) doc->name);
gumbo_parser_deallocate(parser, (void*) doc->public_identifier);
gumbo_parser_deallocate(parser, (void*) doc->system_identifier);
} break;
case GUMBO_NODE_TEMPLATE:
case GUMBO_NODE_ELEMENT:
for (unsigned int i = 0; i < node->v.element.attributes.length; ++i) {
gumbo_destroy_attribute(parser, node->v.element.attributes.data[i]);
}
gumbo_parser_deallocate(parser, node->v.element.attributes.data);
for (unsigned int i = 0; i < node->v.element.children.length; ++i) {
destroy_node(parser, node->v.element.children.data[i]);
}
gumbo_parser_deallocate(parser, node->v.element.children.data);
break;
case GUMBO_NODE_TEXT:
case GUMBO_NODE_CDATA:
case GUMBO_NODE_COMMENT:
case GUMBO_NODE_WHITESPACE:
gumbo_parser_deallocate(parser, (void*) node->v.text.text);
break;
}
gumbo_parser_deallocate(parser, node);
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inbody
static bool handle_in_body(GumboParser* parser, GumboToken* token) {
GumboParserState* state = parser->_parser_state;
assert(state->_open_elements.length > 0);
if (token->type == GUMBO_TOKEN_NULL) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_WHITESPACE) {
reconstruct_active_formatting_elements(parser);
insert_text_token(parser, token);
return true;
} else if (token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_CDATA) {
reconstruct_active_formatting_elements(parser);
insert_text_token(parser, token);
set_frameset_not_ok(parser);
return true;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
parser_add_parse_error(parser, token);
if (has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
ignore_token(parser);
return false;
}
assert(parser->_output->root != NULL);
assert(parser->_output->root->type == GUMBO_NODE_ELEMENT);
merge_attributes(parser, token, parser->_output->root);
return false;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(BASE), TAG(BASEFONT), TAG(BGSOUND),
TAG(MENUITEM), TAG(LINK), TAG(META), TAG(NOFRAMES),
TAG(SCRIPT), TAG(STYLE), TAG(TEMPLATE), TAG(TITLE)}) ||
tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
return handle_in_head(parser, token);
} else if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
parser_add_parse_error(parser, token);
if (state->_open_elements.length < 2 ||
!node_html_tag_is(state->_open_elements.data[1], GUMBO_TAG_BODY) ||
has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
ignore_token(parser);
return false;
}
state->_frameset_ok = false;
merge_attributes(parser, token, state->_open_elements.data[1]);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
parser_add_parse_error(parser, token);
if (state->_open_elements.length < 2 ||
!node_html_tag_is(state->_open_elements.data[1], GUMBO_TAG_BODY) ||
!state->_frameset_ok) {
ignore_token(parser);
return false;
}
// Save the body node for later removal.
GumboNode* body_node = state->_open_elements.data[1];
// Pop all nodes except root HTML element.
GumboNode* node;
do {
node = pop_current_node(parser);
} while (node != state->_open_elements.data[1]);
// Removing & destroying the body node is going to kill any nodes that have
// been added to the list of active formatting elements, and so we should
// clear it to prevent a use-after-free if the list of active formatting
// elements is reconstructed afterwards. This may happen if whitespace
// follows the </frameset>.
clear_active_formatting_elements(parser);
// Remove the body node. We may want to factor this out into a generic
// helper, but right now this is the only code that needs to do this.
GumboVector* children = &parser->_output->root->v.element.children;
for (unsigned int i = 0; i < children->length; ++i) {
if (children->data[i] == body_node) {
gumbo_vector_remove_at(parser, i, children);
break;
}
}
destroy_node(parser, body_node);
// Insert the <frameset>, and switch the insertion mode.
insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_FRAMESET);
return true;
} else if (token->type == GUMBO_TOKEN_EOF) {
for (unsigned int i = 0; i < state->_open_elements.length; ++i) {
if (!node_tag_in_set(state->_open_elements.data[i],
(gumbo_tagset){TAG(DD), TAG(DT), TAG(LI), TAG(P), TAG(TBODY),
TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR), TAG(BODY),
TAG(HTML)})) {
parser_add_parse_error(parser, token);
}
}
if (get_current_template_insertion_mode(parser) !=
GUMBO_INSERTION_MODE_INITIAL) {
return handle_in_template(parser, token);
}
return true;
} else if (tag_in(token, kEndTag, (gumbo_tagset){TAG(BODY), TAG(HTML)})) {
if (!has_an_element_in_scope(parser, GUMBO_TAG_BODY)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
bool success = true;
for (unsigned int i = 0; i < state->_open_elements.length; ++i) {
if (!node_tag_in_set(state->_open_elements.data[i],
(gumbo_tagset){TAG(DD), TAG(DT), TAG(LI), TAG(OPTGROUP),
TAG(OPTION), TAG(P), TAG(RB), TAG(RP), TAG(RT), TAG(RTC),
TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR),
TAG(BODY), TAG(HTML)})) {
parser_add_parse_error(parser, token);
success = false;
break;
}
}
set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_BODY);
if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
parser->_parser_state->_reprocess_current_token = true;
} else {
GumboNode* body = state->_open_elements.data[1];
assert(node_html_tag_is(body, GUMBO_TAG_BODY));
record_end_of_element(state->_current_token, &body->v.element);
}
return success;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(ADDRESS), TAG(ARTICLE), TAG(ASIDE),
TAG(BLOCKQUOTE), TAG(CENTER), TAG(DETAILS), TAG(DIALOG),
TAG(DIR), TAG(DIV), TAG(DL), TAG(FIELDSET), TAG(FIGCAPTION),
TAG(FIGURE), TAG(FOOTER), TAG(HEADER), TAG(HGROUP),
TAG(MENU), TAG(MAIN), TAG(NAV), TAG(OL), TAG(P),
TAG(SECTION), TAG(SUMMARY), TAG(UL)})) {
bool result = maybe_implicitly_close_p_tag(parser, token);
insert_element_from_token(parser, token);
return result;
} else if (tag_in(token, kStartTag, (gumbo_tagset){TAG(H1), TAG(H2), TAG(H3),
TAG(H4), TAG(H5), TAG(H6)})) {
bool result = maybe_implicitly_close_p_tag(parser, token);
if (node_tag_in_set(
get_current_node(parser), (gumbo_tagset){TAG(H1), TAG(H2), TAG(H3),
TAG(H4), TAG(H5), TAG(H6)})) {
parser_add_parse_error(parser, token);
pop_current_node(parser);
result = false;
}
insert_element_from_token(parser, token);
return result;
} else if (tag_in(token, kStartTag, (gumbo_tagset){TAG(PRE), TAG(LISTING)})) {
bool result = maybe_implicitly_close_p_tag(parser, token);
insert_element_from_token(parser, token);
state->_ignore_next_linefeed = true;
state->_frameset_ok = false;
return result;
} else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
if (state->_form_element != NULL &&
!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
gumbo_debug("Ignoring nested form.\n");
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
bool result = maybe_implicitly_close_p_tag(parser, token);
GumboNode* form_element = insert_element_from_token(parser, token);
if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
state->_form_element = form_element;
}
return result;
} else if (tag_is(token, kStartTag, GUMBO_TAG_LI)) {
maybe_implicitly_close_list_tag(parser, token, true);
bool result = maybe_implicitly_close_p_tag(parser, token);
insert_element_from_token(parser, token);
return result;
} else if (tag_in(token, kStartTag, (gumbo_tagset){TAG(DD), TAG(DT)})) {
maybe_implicitly_close_list_tag(parser, token, false);
bool result = maybe_implicitly_close_p_tag(parser, token);
insert_element_from_token(parser, token);
return result;
} else if (tag_is(token, kStartTag, GUMBO_TAG_PLAINTEXT)) {
bool result = maybe_implicitly_close_p_tag(parser, token);
insert_element_from_token(parser, token);
gumbo_tokenizer_set_state(parser, GUMBO_LEX_PLAINTEXT);
return result;
} else if (tag_is(token, kStartTag, GUMBO_TAG_BUTTON)) {
if (has_an_element_in_scope(parser, GUMBO_TAG_BUTTON)) {
parser_add_parse_error(parser, token);
implicitly_close_tags(
parser, token, GUMBO_NAMESPACE_HTML, GUMBO_TAG_BUTTON);
state->_reprocess_current_token = true;
return false;
}
reconstruct_active_formatting_elements(parser);
insert_element_from_token(parser, token);
state->_frameset_ok = false;
return true;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(ADDRESS), TAG(ARTICLE), TAG(ASIDE),
TAG(BLOCKQUOTE), TAG(BUTTON), TAG(CENTER), TAG(DETAILS),
TAG(DIALOG), TAG(DIR), TAG(DIV), TAG(DL), TAG(FIELDSET),
TAG(FIGCAPTION), TAG(FIGURE), TAG(FOOTER), TAG(HEADER),
TAG(HGROUP), TAG(LISTING), TAG(MAIN), TAG(MENU), TAG(NAV),
TAG(OL), TAG(PRE), TAG(SECTION), TAG(SUMMARY), TAG(UL)})) {
GumboTag tag = token->v.end_tag;
if (!has_an_element_in_scope(parser, tag)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
implicitly_close_tags(
parser, token, GUMBO_NAMESPACE_HTML, token->v.end_tag);
return true;
} else if (tag_is(token, kEndTag, GUMBO_TAG_FORM)) {
if (has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
if (!has_an_element_in_scope(parser, GUMBO_TAG_FORM)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
bool success = true;
generate_implied_end_tags(parser, GUMBO_TAG_LAST);
if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_FORM)) {
parser_add_parse_error(parser, token);
return false;
}
while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_FORM))
;
return success;
} else {
bool result = true;
GumboNode* node = state->_form_element;
assert(!node || node->type == GUMBO_NODE_ELEMENT);
state->_form_element = NULL;
if (!node || !has_node_in_scope(parser, node)) {
gumbo_debug("Closing an unopened form.\n");
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
// Since we remove the form node without popping, we need to make sure
// that we flush any text nodes at the end of the form.
maybe_flush_text_node_buffer(parser);
// This differs from implicitly_close_tags because we remove *only* the
// <form> element; other nodes are left in scope.
generate_implied_end_tags(parser, GUMBO_TAG_LAST);
if (get_current_node(parser) == node) {
record_end_of_element(token, &node->v.element);
} else {
parser_add_parse_error(parser, token);
result = false;
}
GumboVector* open_elements = &state->_open_elements;
int index = gumbo_vector_index_of(open_elements, node);
assert(index >= 0);
gumbo_vector_remove_at(parser, index, open_elements);
return result;
}
} else if (tag_is(token, kEndTag, GUMBO_TAG_P)) {
if (!has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
parser_add_parse_error(parser, token);
// reconstruct_active_formatting_elements(parser);
insert_element_of_tag_type(
parser, GUMBO_TAG_P, GUMBO_INSERTION_CONVERTED_FROM_END_TAG);
state->_reprocess_current_token = true;
return false;
}
return implicitly_close_tags(
parser, token, GUMBO_NAMESPACE_HTML, GUMBO_TAG_P);
} else if (tag_is(token, kEndTag, GUMBO_TAG_LI)) {
if (!has_an_element_in_list_scope(parser, GUMBO_TAG_LI)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
return implicitly_close_tags(
parser, token, GUMBO_NAMESPACE_HTML, GUMBO_TAG_LI);
} else if (tag_in(token, kEndTag, (gumbo_tagset){TAG(DD), TAG(DT)})) {
assert(token->type == GUMBO_TOKEN_END_TAG);
GumboTag token_tag = token->v.end_tag;
if (!has_an_element_in_scope(parser, token_tag)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
return implicitly_close_tags(
parser, token, GUMBO_NAMESPACE_HTML, token_tag);
} else if (tag_in(token, kEndTag, (gumbo_tagset){TAG(H1), TAG(H2), TAG(H3),
TAG(H4), TAG(H5), TAG(H6)})) {
if (!has_an_element_in_scope_with_tagname(
parser, 6, (GumboTag[]){GUMBO_TAG_H1, GUMBO_TAG_H2, GUMBO_TAG_H3,
GUMBO_TAG_H4, GUMBO_TAG_H5, GUMBO_TAG_H6})) {
// No heading open; ignore the token entirely.
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
generate_implied_end_tags(parser, GUMBO_TAG_LAST);
const GumboNode* current_node = get_current_node(parser);
bool success = node_html_tag_is(current_node, token->v.end_tag);
if (!success) {
// There're children of the heading currently open; close them below and
// record a parse error.
// TODO(jdtang): Add a way to distinguish this error case from the one
// above.
parser_add_parse_error(parser, token);
}
do {
current_node = pop_current_node(parser);
} while (!node_tag_in_set(
current_node, (gumbo_tagset){TAG(H1), TAG(H2), TAG(H3),
TAG(H4), TAG(H5), TAG(H6)}));
return success;
}
} else if (tag_is(token, kStartTag, GUMBO_TAG_A)) {
bool success = true;
int last_a;
int has_matching_a = find_last_anchor_index(parser, &last_a);
if (has_matching_a) {
assert(has_matching_a == 1);
parser_add_parse_error(parser, token);
adoption_agency_algorithm(parser, token, GUMBO_TAG_A);
// The adoption agency algorithm usually removes all instances of <a>
// from the list of active formatting elements, but in case it doesn't,
// we're supposed to do this. (The conditions where it might not are
// listed in the spec.)
if (find_last_anchor_index(parser, &last_a)) {
void* last_element = gumbo_vector_remove_at(
parser, last_a, &state->_active_formatting_elements);
gumbo_vector_remove(parser, last_element, &state->_open_elements);
}
success = false;
}
reconstruct_active_formatting_elements(parser);
add_formatting_element(parser, insert_element_from_token(parser, token));
return success;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(B), TAG(BIG), TAG(CODE), TAG(EM), TAG(FONT),
TAG(I), TAG(S), TAG(SMALL), TAG(STRIKE), TAG(STRONG),
TAG(TT), TAG(U)})) {
reconstruct_active_formatting_elements(parser);
add_formatting_element(parser, insert_element_from_token(parser, token));
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_NOBR)) {
bool result = true;
reconstruct_active_formatting_elements(parser);
if (has_an_element_in_scope(parser, GUMBO_TAG_NOBR)) {
result = false;
parser_add_parse_error(parser, token);
adoption_agency_algorithm(parser, token, GUMBO_TAG_NOBR);
reconstruct_active_formatting_elements(parser);
}
insert_element_from_token(parser, token);
add_formatting_element(parser, get_current_node(parser));
return result;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(A), TAG(B), TAG(BIG), TAG(CODE), TAG(EM),
TAG(FONT), TAG(I), TAG(NOBR), TAG(S), TAG(SMALL),
TAG(STRIKE), TAG(STRONG), TAG(TT), TAG(U)})) {
return adoption_agency_algorithm(parser, token, token->v.end_tag);
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(APPLET), TAG(MARQUEE), TAG(OBJECT)})) {
reconstruct_active_formatting_elements(parser);
insert_element_from_token(parser, token);
add_formatting_element(parser, &kActiveFormattingScopeMarker);
set_frameset_not_ok(parser);
return true;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(APPLET), TAG(MARQUEE), TAG(OBJECT)})) {
GumboTag token_tag = token->v.end_tag;
if (!has_an_element_in_table_scope(parser, token_tag)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
implicitly_close_tags(parser, token, GUMBO_NAMESPACE_HTML, token_tag);
clear_active_formatting_elements(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
if (get_document_node(parser)->v.document.doc_type_quirks_mode !=
GUMBO_DOCTYPE_QUIRKS) {
maybe_implicitly_close_p_tag(parser, token);
}
insert_element_from_token(parser, token);
set_frameset_not_ok(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(AREA), TAG(BR), TAG(EMBED), TAG(IMG),
TAG(IMAGE), TAG(KEYGEN), TAG(WBR)})) {
bool success = true;
if (tag_is(token, kStartTag, GUMBO_TAG_IMAGE)) {
success = false;
parser_add_parse_error(parser, token);
token->v.start_tag.tag = GUMBO_TAG_IMG;
}
reconstruct_active_formatting_elements(parser);
GumboNode* node = insert_element_from_token(parser, token);
if (tag_is(token, kStartTag, GUMBO_TAG_IMAGE)) {
success = false;
parser_add_parse_error(parser, token);
node->v.element.tag = GUMBO_TAG_IMG;
node->parse_flags |= GUMBO_INSERTION_FROM_IMAGE;
}
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
set_frameset_not_ok(parser);
return success;
} else if (tag_is(token, kStartTag, GUMBO_TAG_INPUT)) {
if (!attribute_matches(&token->v.start_tag.attributes, "type", "hidden")) {
// Must be before the element is inserted, as that takes ownership of the
// token's attribute vector.
set_frameset_not_ok(parser);
}
reconstruct_active_formatting_elements(parser);
insert_element_from_token(parser, token);
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(PARAM), TAG(SOURCE), TAG(TRACK)})) {
insert_element_from_token(parser, token);
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HR)) {
bool result = maybe_implicitly_close_p_tag(parser, token);
insert_element_from_token(parser, token);
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
set_frameset_not_ok(parser);
return result;
} else if (tag_is(token, kStartTag, GUMBO_TAG_ISINDEX)) {
parser_add_parse_error(parser, token);
if (parser->_parser_state->_form_element != NULL &&
!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
ignore_token(parser);
return false;
}
acknowledge_self_closing_tag(parser);
maybe_implicitly_close_p_tag(parser, token);
set_frameset_not_ok(parser);
GumboVector* token_attrs = &token->v.start_tag.attributes;
GumboAttribute* prompt_attr = gumbo_get_attribute(token_attrs, "prompt");
GumboAttribute* action_attr = gumbo_get_attribute(token_attrs, "action");
GumboAttribute* name_attr = gumbo_get_attribute(token_attrs, "name");
GumboNode* form = insert_element_of_tag_type(
parser, GUMBO_TAG_FORM, GUMBO_INSERTION_FROM_ISINDEX);
if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
parser->_parser_state->_form_element = form;
}
if (action_attr) {
gumbo_vector_add(parser, action_attr, &form->v.element.attributes);
}
insert_element_of_tag_type(
parser, GUMBO_TAG_HR, GUMBO_INSERTION_FROM_ISINDEX);
pop_current_node(parser); // <hr>
insert_element_of_tag_type(
parser, GUMBO_TAG_LABEL, GUMBO_INSERTION_FROM_ISINDEX);
TextNodeBufferState* text_state = &parser->_parser_state->_text_node;
text_state->_start_original_text = token->original_text.data;
text_state->_start_position = token->position;
text_state->_type = GUMBO_NODE_TEXT;
if (prompt_attr) {
int prompt_attr_length = strlen(prompt_attr->value);
gumbo_string_buffer_destroy(parser, &text_state->_buffer);
text_state->_buffer.data = gumbo_copy_stringz(parser, prompt_attr->value);
text_state->_buffer.length = prompt_attr_length;
text_state->_buffer.capacity = prompt_attr_length + 1;
gumbo_destroy_attribute(parser, prompt_attr);
} else {
GumboStringPiece prompt_text =
GUMBO_STRING("This is a searchable index. Enter search keywords: ");
gumbo_string_buffer_append_string(
parser, &prompt_text, &text_state->_buffer);
}
GumboNode* input = insert_element_of_tag_type(
parser, GUMBO_TAG_INPUT, GUMBO_INSERTION_FROM_ISINDEX);
for (unsigned int i = 0; i < token_attrs->length; ++i) {
GumboAttribute* attr = token_attrs->data[i];
if (attr != prompt_attr && attr != action_attr && attr != name_attr) {
gumbo_vector_add(parser, attr, &input->v.element.attributes);
}
token_attrs->data[i] = NULL;
}
// All attributes have been successfully transferred and nulled out at this
// point, so the call to ignore_token will free the memory for it without
// touching the attributes.
ignore_token(parser);
// The name attribute, if present, should be destroyed since it's ignored
// when copying over. The action attribute should be kept since it's moved
// to the form.
if (name_attr) {
gumbo_destroy_attribute(parser, name_attr);
}
GumboAttribute* name =
gumbo_parser_allocate(parser, sizeof(GumboAttribute));
GumboStringPiece name_str = GUMBO_STRING("name");
GumboStringPiece isindex_str = GUMBO_STRING("isindex");
name->attr_namespace = GUMBO_ATTR_NAMESPACE_NONE;
name->name = gumbo_copy_stringz(parser, "name");
name->value = gumbo_copy_stringz(parser, "isindex");
name->original_name = name_str;
name->original_value = isindex_str;
name->name_start = kGumboEmptySourcePosition;
name->name_end = kGumboEmptySourcePosition;
name->value_start = kGumboEmptySourcePosition;
name->value_end = kGumboEmptySourcePosition;
gumbo_vector_add(parser, name, &input->v.element.attributes);
pop_current_node(parser); // <input>
pop_current_node(parser); // <label>
insert_element_of_tag_type(
parser, GUMBO_TAG_HR, GUMBO_INSERTION_FROM_ISINDEX);
pop_current_node(parser); // <hr>
pop_current_node(parser); // <form>
if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
parser->_parser_state->_form_element = NULL;
}
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_TEXTAREA)) {
run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RCDATA);
parser->_parser_state->_ignore_next_linefeed = true;
set_frameset_not_ok(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_XMP)) {
bool result = maybe_implicitly_close_p_tag(parser, token);
reconstruct_active_formatting_elements(parser);
set_frameset_not_ok(parser);
run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
return result;
} else if (tag_is(token, kStartTag, GUMBO_TAG_IFRAME)) {
set_frameset_not_ok(parser);
run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_NOEMBED)) {
run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
reconstruct_active_formatting_elements(parser);
insert_element_from_token(parser, token);
set_frameset_not_ok(parser);
GumboInsertionMode state = parser->_parser_state->_insertion_mode;
if (state == GUMBO_INSERTION_MODE_IN_TABLE ||
state == GUMBO_INSERTION_MODE_IN_CAPTION ||
state == GUMBO_INSERTION_MODE_IN_TABLE_BODY ||
state == GUMBO_INSERTION_MODE_IN_ROW ||
state == GUMBO_INSERTION_MODE_IN_CELL) {
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_SELECT_IN_TABLE);
} else {
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_SELECT);
}
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(OPTION), TAG(OPTGROUP)})) {
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
pop_current_node(parser);
}
reconstruct_active_formatting_elements(parser);
insert_element_from_token(parser, token);
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(RB), TAG(RP), TAG(RT), TAG(RTC)})) {
bool success = true;
GumboTag exception =
tag_in(token, kStartTag, (gumbo_tagset){TAG(RT), TAG(RP)})
? GUMBO_TAG_RTC
: GUMBO_TAG_LAST;
if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
generate_implied_end_tags(parser, exception);
}
if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY) &&
!(exception == GUMBO_TAG_LAST ||
node_html_tag_is(get_current_node(parser), GUMBO_TAG_RTC))) {
parser_add_parse_error(parser, token);
success = false;
}
insert_element_from_token(parser, token);
return success;
} else if (tag_is(token, kEndTag, GUMBO_TAG_BR)) {
parser_add_parse_error(parser, token);
reconstruct_active_formatting_elements(parser);
insert_element_of_tag_type(
parser, GUMBO_TAG_BR, GUMBO_INSERTION_CONVERTED_FROM_END_TAG);
pop_current_node(parser);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_MATH)) {
reconstruct_active_formatting_elements(parser);
adjust_mathml_attributes(parser, token);
adjust_foreign_attributes(parser, token);
insert_foreign_element(parser, token, GUMBO_NAMESPACE_MATHML);
if (token->v.start_tag.is_self_closing) {
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
}
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_SVG)) {
reconstruct_active_formatting_elements(parser);
adjust_svg_attributes(parser, token);
adjust_foreign_attributes(parser, token);
insert_foreign_element(parser, token, GUMBO_NAMESPACE_SVG);
if (token->v.start_tag.is_self_closing) {
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
}
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(CAPTION), TAG(COL), TAG(COLGROUP),
TAG(FRAME), TAG(HEAD), TAG(TBODY), TAG(TD), TAG(TFOOT),
TAG(TH), TAG(THEAD), TAG(TR)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_START_TAG) {
reconstruct_active_formatting_elements(parser);
insert_element_from_token(parser, token);
return true;
} else {
assert(token->type == GUMBO_TOKEN_END_TAG);
GumboTag end_tag = token->v.end_tag;
assert(state->_open_elements.length > 0);
assert(node_html_tag_is(state->_open_elements.data[0], GUMBO_TAG_HTML));
// Walk up the stack of open elements until we find one that either:
// a) Matches the tag name we saw
// b) Is in the "special" category.
// If we see a), implicitly close everything up to and including it. If we
// see b), then record a parse error, don't close anything (except the
// implied end tags) and ignore the end tag token.
for (int i = state->_open_elements.length; --i >= 0;) {
const GumboNode* node = state->_open_elements.data[i];
if (node_html_tag_is(node, end_tag)) {
generate_implied_end_tags(parser, end_tag);
// TODO(jdtang): Do I need to add a parse error here? The condition in
// the spec seems like it's the inverse of the loop condition above, and
// so would never fire.
while (node != pop_current_node(parser))
; // Pop everything.
return true;
} else if (is_special_node(node)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
}
// <html> is in the special category, so we should never get here.
assert(0);
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-incdata
static bool handle_text(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
} else {
// We provide only bare-bones script handling that doesn't involve any of
// the parser-pause/already-started/script-nesting flags or re-entrant
// invocations of the tokenizer. Because the intended usage of this library
// is mostly for templating, refactoring, and static-analysis libraries, we
// provide the script body as a text-node child of the <script> element.
// This behavior doesn't support document.write of partial HTML elements,
// but should be adequate for almost all other scripting support.
if (token->type == GUMBO_TOKEN_EOF) {
parser_add_parse_error(parser, token);
parser->_parser_state->_reprocess_current_token = true;
}
pop_current_node(parser);
set_insertion_mode(parser, parser->_parser_state->_original_insertion_mode);
}
return true;
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-intable
static bool handle_in_table(GumboParser* parser, GumboToken* token) {
GumboParserState* state = parser->_parser_state;
if (token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_WHITESPACE) {
// The "pending table character tokens" list described in the spec is
// nothing more than the TextNodeBufferState. We accumulate text tokens as
// normal, except that when we go to flush them in the handle_in_table_text,
// we set _foster_parent_insertions if there're non-whitespace characters in
// the buffer.
assert(state->_text_node._buffer.length == 0);
state->_original_insertion_mode = state->_insertion_mode;
state->_reprocess_current_token = true;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_TEXT);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_CAPTION)) {
clear_stack_to_table_context(parser);
add_formatting_element(parser, &kActiveFormattingScopeMarker);
insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_CAPTION);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_COLGROUP)) {
clear_stack_to_table_context(parser);
insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
clear_stack_to_table_context(parser);
insert_element_of_tag_type(
parser, GUMBO_TAG_COLGROUP, GUMBO_INSERTION_IMPLIED);
parser->_parser_state->_reprocess_current_token = true;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TD),
TAG(TH), TAG(TR)})) {
clear_stack_to_table_context(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
if (tag_in(token, kStartTag, (gumbo_tagset){TAG(TD), TAG(TH), TAG(TR)})) {
insert_element_of_tag_type(
parser, GUMBO_TAG_TBODY, GUMBO_INSERTION_IMPLIED);
state->_reprocess_current_token = true;
} else {
insert_element_from_token(parser, token);
}
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
parser_add_parse_error(parser, token);
if (close_table(parser)) {
parser->_parser_state->_reprocess_current_token = true;
} else {
ignore_token(parser);
}
return false;
} else if (tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
if (!close_table(parser)) {
parser_add_parse_error(parser, token);
return false;
}
return true;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(BODY), TAG(CAPTION), TAG(COL),
TAG(COLGROUP), TAG(HTML), TAG(TBODY), TAG(TD), TAG(TFOOT),
TAG(TH), TAG(THEAD), TAG(TR)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(STYLE), TAG(SCRIPT), TAG(TEMPLATE)}) ||
(tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE))) {
return handle_in_head(parser, token);
} else if (tag_is(token, kStartTag, GUMBO_TAG_INPUT) &&
attribute_matches(
&token->v.start_tag.attributes, "type", "hidden")) {
parser_add_parse_error(parser, token);
insert_element_from_token(parser, token);
pop_current_node(parser);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
parser_add_parse_error(parser, token);
if (state->_form_element || has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
ignore_token(parser);
return false;
}
state->_form_element = insert_element_from_token(parser, token);
pop_current_node(parser);
return false;
} else if (token->type == GUMBO_TOKEN_EOF) {
return handle_in_body(parser, token);
} else {
parser_add_parse_error(parser, token);
state->_foster_parent_insertions = true;
bool result = handle_in_body(parser, token);
state->_foster_parent_insertions = false;
return result;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-intabletext
static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_NULL) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
return true;
} else {
GumboParserState* state = parser->_parser_state;
GumboStringBuffer* buffer = &state->_text_node._buffer;
// Can't use strspn for this because GumboStringBuffers are not
// null-terminated.
// Note that TextNodeBuffer may contain UTF-8 characters, but the presence
// of any one byte that is not whitespace means we flip the flag, so this
// loop is still valid.
for (unsigned int i = 0; i < buffer->length; ++i) {
if (!isspace((unsigned char) buffer->data[i]) ||
buffer->data[i] == '\v') {
state->_foster_parent_insertions = true;
reconstruct_active_formatting_elements(parser);
break;
}
}
maybe_flush_text_node_buffer(parser);
state->_foster_parent_insertions = false;
state->_reprocess_current_token = true;
state->_insertion_mode = state->_original_insertion_mode;
return true;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-incaption
static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
if (tag_is(token, kEndTag, GUMBO_TAG_CAPTION)) {
if (!has_an_element_in_table_scope(parser, GUMBO_TAG_CAPTION)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
generate_implied_end_tags(parser, GUMBO_TAG_LAST);
bool result = true;
if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION)) {
parser_add_parse_error(parser, token);
}
while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_CAPTION))
;
clear_active_formatting_elements(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
return result;
}
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(CAPTION), TAG(COL), TAG(COLGROUP),
TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD),
TAG(TR)}) ||
(tag_is(token, kEndTag, GUMBO_TAG_TABLE))) {
if (!has_an_element_in_table_scope(parser, GUMBO_TAG_CAPTION)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_CAPTION))
;
clear_active_formatting_elements(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
parser->_parser_state->_reprocess_current_token = true;
return true;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(BODY), TAG(COL), TAG(COLGROUP), TAG(HTML),
TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD),
TAG(TR)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
return handle_in_body(parser, token);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-incolgroup
static bool handle_in_column_group(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
insert_element_from_token(parser, token);
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
return true;
} else if (tag_is(token, kEndTag, GUMBO_TAG_COLGROUP)) {
if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
return false;
} else if (tag_is(token, kEndTag, GUMBO_TAG_COL)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE) ||
tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
return handle_in_head(parser, token);
} else if (token->type == GUMBO_TOKEN_EOF) {
return handle_in_body(parser, token);
} else {
if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
parser->_parser_state->_reprocess_current_token = true;
return true;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-intbody
static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
if (tag_is(token, kStartTag, GUMBO_TAG_TR)) {
clear_stack_to_table_body_context(parser);
insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
return true;
} else if (tag_in(token, kStartTag, (gumbo_tagset){TAG(TD), TAG(TH)})) {
parser_add_parse_error(parser, token);
clear_stack_to_table_body_context(parser);
insert_element_of_tag_type(parser, GUMBO_TAG_TR, GUMBO_INSERTION_IMPLIED);
parser->_parser_state->_reprocess_current_token = true;
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
return false;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(TBODY), TAG(TFOOT), TAG(THEAD)})) {
if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
clear_stack_to_table_body_context(parser);
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
return true;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(CAPTION), TAG(COL), TAG(COLGROUP),
TAG(TBODY), TAG(TFOOT), TAG(THEAD)}) ||
tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
if (!(has_an_element_in_table_scope(parser, GUMBO_TAG_TBODY) ||
has_an_element_in_table_scope(parser, GUMBO_TAG_THEAD) ||
has_an_element_in_table_scope(parser, GUMBO_TAG_TFOOT))) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
clear_stack_to_table_body_context(parser);
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
parser->_parser_state->_reprocess_current_token = true;
return true;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(BODY), TAG(CAPTION), TAG(COL), TAG(TR),
TAG(COLGROUP), TAG(HTML), TAG(TD), TAG(TH)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
return handle_in_table(parser, token);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-intr
static bool handle_in_row(GumboParser* parser, GumboToken* token) {
if (tag_in(token, kStartTag, (gumbo_tagset){TAG(TH), TAG(TD)})) {
clear_stack_to_table_row_context(parser);
insert_element_from_token(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_CELL);
add_formatting_element(parser, &kActiveFormattingScopeMarker);
return true;
} else if (tag_is(token, kEndTag, GUMBO_TAG_TR)) {
if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TR)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
clear_stack_to_table_row_context(parser);
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
return true;
}
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(CAPTION), TAG(COL), TAG(COLGROUP),
TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR)}) ||
tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TR)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
clear_stack_to_table_row_context(parser);
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
parser->_parser_state->_reprocess_current_token = true;
return true;
}
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(TBODY), TAG(TFOOT), TAG(THEAD)})) {
if (!has_an_element_in_table_scope(parser, token->v.end_tag) ||
(!has_an_element_in_table_scope(parser, GUMBO_TAG_TR))) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
clear_stack_to_table_row_context(parser);
pop_current_node(parser);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
parser->_parser_state->_reprocess_current_token = true;
return true;
}
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(BODY), TAG(CAPTION), TAG(COL),
TAG(COLGROUP), TAG(HTML), TAG(TD), TAG(TH)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else {
return handle_in_table(parser, token);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-intd
static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
if (tag_in(token, kEndTag, (gumbo_tagset){TAG(TD), TAG(TH)})) {
GumboTag token_tag = token->v.end_tag;
if (!has_an_element_in_table_scope(parser, token_tag)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
return close_table_cell(parser, token, token_tag);
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(CAPTION), TAG(COL), TAG(COLGROUP),
TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD),
TAG(TR)})) {
gumbo_debug("Handling <td> in cell.\n");
if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TH) &&
!has_an_element_in_table_scope(parser, GUMBO_TAG_TD)) {
gumbo_debug("Bailing out because there's no <td> or <th> in scope.\n");
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
parser->_parser_state->_reprocess_current_token = true;
return close_current_cell(parser, token);
} else if (tag_in(token, kEndTag, (gumbo_tagset){TAG(BODY), TAG(CAPTION),
TAG(COL), TAG(COLGROUP), TAG(HTML)})) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (tag_in(token, kEndTag, (gumbo_tagset){TAG(TABLE), TAG(TBODY),
TAG(TFOOT), TAG(THEAD), TAG(TR)})) {
if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
parser->_parser_state->_reprocess_current_token = true;
return close_current_cell(parser, token);
} else {
return handle_in_body(parser, token);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inselect
static bool handle_in_select(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_NULL) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (tag_is(token, kStartTag, GUMBO_TAG_OPTION)) {
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
pop_current_node(parser);
}
insert_element_from_token(parser, token);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_OPTGROUP)) {
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
pop_current_node(parser);
}
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTGROUP)) {
pop_current_node(parser);
}
insert_element_from_token(parser, token);
return true;
} else if (tag_is(token, kEndTag, GUMBO_TAG_OPTGROUP)) {
GumboVector* open_elements = &parser->_parser_state->_open_elements;
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION) &&
node_html_tag_is(open_elements->data[open_elements->length - 2],
GUMBO_TAG_OPTGROUP)) {
pop_current_node(parser);
}
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTGROUP)) {
pop_current_node(parser);
return true;
} else {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
} else if (tag_is(token, kEndTag, GUMBO_TAG_OPTION)) {
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
pop_current_node(parser);
return true;
} else {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
} else if (tag_is(token, kEndTag, GUMBO_TAG_SELECT)) {
if (!has_an_element_in_select_scope(parser, GUMBO_TAG_SELECT)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
close_current_select(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
if (has_an_element_in_select_scope(parser, GUMBO_TAG_SELECT)) {
close_current_select(parser);
}
return false;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(INPUT), TAG(KEYGEN), TAG(TEXTAREA)})) {
parser_add_parse_error(parser, token);
if (!has_an_element_in_select_scope(parser, GUMBO_TAG_SELECT)) {
ignore_token(parser);
} else {
close_current_select(parser);
parser->_parser_state->_reprocess_current_token = true;
}
return false;
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(SCRIPT), TAG(TEMPLATE)}) ||
tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
return handle_in_head(parser, token);
} else if (token->type == GUMBO_TOKEN_EOF) {
return handle_in_body(parser, token);
} else {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inselectintable
static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(CAPTION), TAG(TABLE), TAG(TBODY), TAG(TFOOT),
TAG(THEAD), TAG(TR), TAG(TD), TAG(TH)})) {
parser_add_parse_error(parser, token);
close_current_select(parser);
parser->_parser_state->_reprocess_current_token = true;
return false;
} else if (tag_in(token, kEndTag,
(gumbo_tagset){TAG(CAPTION), TAG(TABLE), TAG(TBODY),
TAG(TFOOT), TAG(THEAD), TAG(TR), TAG(TD), TAG(TH)})) {
parser_add_parse_error(parser, token);
if (!has_an_element_in_table_scope(parser, token->v.end_tag)) {
ignore_token(parser);
return false;
} else {
close_current_select(parser);
// close_current_select already does the
// reset_insertion_mode_appropriately
// reset_insertion_mode_appropriately(parser);
parser->_parser_state->_reprocess_current_token = true;
return false;
}
} else {
return handle_in_select(parser, token);
}
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#parsing-main-intemplate
static bool handle_in_template(GumboParser* parser, GumboToken* token) {
GumboParserState* state = parser->_parser_state;
if (token->type == GUMBO_TOKEN_WHITESPACE ||
token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_COMMENT || token->type == GUMBO_TOKEN_NULL ||
token->type == GUMBO_TOKEN_DOCTYPE) {
return handle_in_body(parser, token);
} else if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(BASE), TAG(BASEFONT), TAG(BGSOUND),
TAG(LINK), TAG(META), TAG(NOFRAMES), TAG(SCRIPT),
TAG(STYLE), TAG(TEMPLATE), TAG(TITLE)}) ||
tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
return handle_in_head(parser, token);
} else if (tag_in(
token, kStartTag, (gumbo_tagset){TAG(CAPTION), TAG(COLGROUP),
TAG(TBODY), TAG(TFOOT), TAG(THEAD)})) {
pop_template_insertion_mode(parser);
push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
state->_reprocess_current_token = true;
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
pop_template_insertion_mode(parser);
push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
state->_reprocess_current_token = true;
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_TR)) {
pop_template_insertion_mode(parser);
push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
state->_reprocess_current_token = true;
return true;
} else if (tag_in(token, kStartTag, (gumbo_tagset){TAG(TD), TAG(TH)})) {
pop_template_insertion_mode(parser);
push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
state->_reprocess_current_token = true;
return true;
} else if (token->type == GUMBO_TOKEN_START_TAG) {
pop_template_insertion_mode(parser);
push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
state->_reprocess_current_token = true;
return true;
} else if (token->type == GUMBO_TOKEN_END_TAG) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (token->type == GUMBO_TOKEN_EOF) {
if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
// Stop parsing.
return true;
}
parser_add_parse_error(parser, token);
while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_TEMPLATE))
;
clear_active_formatting_elements(parser);
pop_template_insertion_mode(parser);
reset_insertion_mode_appropriately(parser);
state->_reprocess_current_token = true;
return false;
} else {
assert(0);
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-afterbody
static bool handle_after_body(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_WHITESPACE ||
tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (token->type == GUMBO_TOKEN_COMMENT) {
GumboNode* html_node = parser->_output->root;
assert(html_node != NULL);
append_comment_node(parser, html_node, token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
/* fragment case: ignore the closing HTML token */
if (is_fragment_parser(parser)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_BODY);
GumboNode* html = parser->_parser_state->_open_elements.data[0];
assert(node_html_tag_is(html, GUMBO_TAG_HTML));
record_end_of_element(
parser->_parser_state->_current_token, &html->v.element);
return true;
} else if (token->type == GUMBO_TOKEN_EOF) {
return true;
} else {
parser_add_parse_error(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
parser->_parser_state->_reprocess_current_token = true;
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inframeset
static bool handle_in_frameset(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
return true;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
insert_element_from_token(parser, token);
return true;
} else if (tag_is(token, kEndTag, GUMBO_TAG_FRAMESET)) {
if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
pop_current_node(parser);
if (!is_fragment_parser(parser) &&
!node_html_tag_is(get_current_node(parser), GUMBO_TAG_FRAMESET)) {
set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_FRAMESET);
}
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_FRAME)) {
insert_element_from_token(parser, token);
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
return handle_in_head(parser, token);
} else if (token->type == GUMBO_TOKEN_EOF) {
if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
parser_add_parse_error(parser, token);
return false;
}
return true;
} else {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-afterframeset
static bool handle_after_frameset(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_WHITESPACE) {
insert_text_token(parser, token);
return true;
} else if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_current_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE) {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
} else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
GumboNode* html = parser->_parser_state->_open_elements.data[0];
assert(node_html_tag_is(html, GUMBO_TAG_HTML));
record_end_of_element(
parser->_parser_state->_current_token, &html->v.element);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_FRAMESET);
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
return handle_in_head(parser, token);
} else if (token->type == GUMBO_TOKEN_EOF) {
return true;
} else {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#the-after-after-body-insertion-mode
static bool handle_after_after_body(GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_document_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE ||
token->type == GUMBO_TOKEN_WHITESPACE ||
tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (token->type == GUMBO_TOKEN_EOF) {
return true;
} else {
parser_add_parse_error(parser, token);
set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
parser->_parser_state->_reprocess_current_token = true;
return false;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#the-after-after-frameset-insertion-mode
static bool handle_after_after_frameset(
GumboParser* parser, GumboToken* token) {
if (token->type == GUMBO_TOKEN_COMMENT) {
append_comment_node(parser, get_document_node(parser), token);
return true;
} else if (token->type == GUMBO_TOKEN_DOCTYPE ||
token->type == GUMBO_TOKEN_WHITESPACE ||
tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
return handle_in_body(parser, token);
} else if (token->type == GUMBO_TOKEN_EOF) {
return true;
} else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
return handle_in_head(parser, token);
} else {
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
}
}
// Function pointers for each insertion mode. Keep in sync with
// insertion_mode.h.
typedef bool (*TokenHandler)(GumboParser* parser, GumboToken* token);
static const TokenHandler kTokenHandlers[] = {handle_initial,
handle_before_html, handle_before_head, handle_in_head,
handle_in_head_noscript, handle_after_head, handle_in_body, handle_text,
handle_in_table, handle_in_table_text, handle_in_caption,
handle_in_column_group, handle_in_table_body, handle_in_row, handle_in_cell,
handle_in_select, handle_in_select_in_table, handle_in_template,
handle_after_body, handle_in_frameset, handle_after_frameset,
handle_after_after_body, handle_after_after_frameset};
static bool handle_html_content(GumboParser* parser, GumboToken* token) {
return kTokenHandlers[(unsigned int) parser->_parser_state->_insertion_mode](
parser, token);
}
// http://www.whatwg.org/specs/web-apps/current-work/complete/tokenization.html#parsing-main-inforeign
static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
gumbo_debug("Handling foreign content");
switch (token->type) {
case GUMBO_TOKEN_NULL:
parser_add_parse_error(parser, token);
token->v.character = kUtf8ReplacementChar;
insert_text_token(parser, token);
return false;
case GUMBO_TOKEN_WHITESPACE:
insert_text_token(parser, token);
return true;
case GUMBO_TOKEN_CDATA:
case GUMBO_TOKEN_CHARACTER:
insert_text_token(parser, token);
set_frameset_not_ok(parser);
return true;
case GUMBO_TOKEN_COMMENT:
append_comment_node(parser, get_current_node(parser), token);
return true;
case GUMBO_TOKEN_DOCTYPE:
parser_add_parse_error(parser, token);
ignore_token(parser);
return false;
default:
// Fall through to the if-statements below.
break;
}
// Order matters for these clauses.
if (tag_in(token, kStartTag,
(gumbo_tagset){TAG(B), TAG(BIG), TAG(BLOCKQUOTE), TAG(BODY), TAG(BR),
TAG(CENTER), TAG(CODE), TAG(DD), TAG(DIV), TAG(DL), TAG(DT),
TAG(EM), TAG(EMBED), TAG(H1), TAG(H2), TAG(H3), TAG(H4), TAG(H5),
TAG(H6), TAG(HEAD), TAG(HR), TAG(I), TAG(IMG), TAG(LI),
TAG(LISTING), TAG(MENU), TAG(META), TAG(NOBR), TAG(OL), TAG(P),
TAG(PRE), TAG(RUBY), TAG(S), TAG(SMALL), TAG(SPAN), TAG(STRONG),
TAG(STRIKE), TAG(SUB), TAG(SUP), TAG(TABLE), TAG(TT), TAG(U),
TAG(UL), TAG(VAR)}) ||
(tag_is(token, kStartTag, GUMBO_TAG_FONT) &&
(token_has_attribute(token, "color") ||
token_has_attribute(token, "face") ||
token_has_attribute(token, "size")))) {
/* Parse error */
parser_add_parse_error(parser, token);
/*
* Fragment case: If the parser was originally created for the HTML
* fragment parsing algorithm, then act as described in the "any other
* start tag" entry below.
*/
if (!is_fragment_parser(parser)) {
do {
pop_current_node(parser);
} while (!(is_mathml_integration_point(get_current_node(parser)) ||
is_html_integration_point(get_current_node(parser)) ||
get_current_node(parser)->v.element.tag_namespace ==
GUMBO_NAMESPACE_HTML));
parser->_parser_state->_reprocess_current_token = true;
return false;
}
assert(token->type == GUMBO_TOKEN_START_TAG);
}
if (token->type == GUMBO_TOKEN_START_TAG) {
const GumboNamespaceEnum current_namespace =
get_adjusted_current_node(parser)->v.element.tag_namespace;
if (current_namespace == GUMBO_NAMESPACE_MATHML) {
adjust_mathml_attributes(parser, token);
}
if (current_namespace == GUMBO_NAMESPACE_SVG) {
// Tag adjustment is left to the gumbo_normalize_svg_tagname helper
// function.
adjust_svg_attributes(parser, token);
}
adjust_foreign_attributes(parser, token);
insert_foreign_element(parser, token, current_namespace);
if (token->v.start_tag.is_self_closing) {
pop_current_node(parser);
acknowledge_self_closing_tag(parser);
}
return true;
// </script> tags are handled like any other end tag, putting the script's
// text into a text node child and closing the current node.
} else {
assert(token->type == GUMBO_TOKEN_END_TAG);
GumboNode* node = get_current_node(parser);
assert(node != NULL);
GumboStringPiece token_tagname = token->original_text;
GumboStringPiece node_tagname = node->v.element.original_tag;
gumbo_tag_from_original_text(&token_tagname);
gumbo_tag_from_original_text(&node_tagname);
bool is_success = true;
if (!gumbo_string_equals_ignore_case(&node_tagname, &token_tagname)) {
parser_add_parse_error(parser, token);
is_success = false;
}
int i = parser->_parser_state->_open_elements.length;
for (--i; i > 0;) {
// Here we move up the stack until we find an HTML element (in which
// case we do nothing) or we find the element that we're about to
// close (in which case we pop everything we've seen until that
// point.)
gumbo_debug("Foreign %.*s node at %d.\n", node_tagname.length,
node_tagname.data, i);
if (gumbo_string_equals_ignore_case(&node_tagname, &token_tagname)) {
gumbo_debug("Matches.\n");
while (pop_current_node(parser) != node) {
// Pop all the nodes below the current one. Node is guaranteed to
// be an element on the stack of open elements (set below), so
// this loop is guaranteed to terminate.
}
return is_success;
}
--i;
node = parser->_parser_state->_open_elements.data[i];
if (node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML) {
// Must break before gumbo_tag_from_original_text to avoid passing
// parser-inserted nodes through.
break;
}
node_tagname = node->v.element.original_tag;
gumbo_tag_from_original_text(&node_tagname);
}
assert(node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML);
// We can't call handle_token directly because the current node is still in
// the SVG namespace, so it would re-enter this and result in infinite
// recursion.
return handle_html_content(parser, token) && is_success;
}
}
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#tree-construction
static bool handle_token(GumboParser* parser, GumboToken* token) {
if (parser->_parser_state->_ignore_next_linefeed &&
token->type == GUMBO_TOKEN_WHITESPACE && token->v.character == '\n') {
parser->_parser_state->_ignore_next_linefeed = false;
ignore_token(parser);
return true;
}
// This needs to be reset both here and in the conditional above to catch both
// the case where the next token is not whitespace (so we don't ignore
// whitespace in the middle of <pre> tags) and where there are multiple
// whitespace tokens (so we don't ignore the second one).
parser->_parser_state->_ignore_next_linefeed = false;
if (tag_is(token, kEndTag, GUMBO_TAG_BODY)) {
parser->_parser_state->_closed_body_tag = true;
}
if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
parser->_parser_state->_closed_html_tag = true;
}
const GumboNode* current_node = get_adjusted_current_node(parser);
assert(!current_node || current_node->type == GUMBO_NODE_ELEMENT ||
current_node->type == GUMBO_NODE_TEMPLATE);
if (current_node) {
gumbo_debug("Current node: <%s>.\n",
gumbo_normalized_tagname(current_node->v.element.tag));
}
if (!current_node ||
current_node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML ||
(is_mathml_integration_point(current_node) &&
(token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_WHITESPACE ||
token->type == GUMBO_TOKEN_NULL ||
(token->type == GUMBO_TOKEN_START_TAG &&
!tag_in(token, kStartTag,
(gumbo_tagset){TAG(MGLYPH), TAG(MALIGNMARK)})))) ||
(current_node->v.element.tag_namespace == GUMBO_NAMESPACE_MATHML &&
node_qualified_tag_is(
current_node, GUMBO_NAMESPACE_MATHML, GUMBO_TAG_ANNOTATION_XML) &&
tag_is(token, kStartTag, GUMBO_TAG_SVG)) ||
(is_html_integration_point(current_node) &&
(token->type == GUMBO_TOKEN_START_TAG ||
token->type == GUMBO_TOKEN_CHARACTER ||
token->type == GUMBO_TOKEN_NULL ||
token->type == GUMBO_TOKEN_WHITESPACE)) ||
token->type == GUMBO_TOKEN_EOF) {
return handle_html_content(parser, token);
} else {
return handle_in_foreign_content(parser, token);
}
}
static void fragment_parser_init(GumboParser* parser, GumboTag fragment_ctx,
GumboNamespaceEnum fragment_namespace) {
GumboNode* root;
assert(fragment_ctx != GUMBO_TAG_LAST);
// 3
parser->_parser_state->_fragment_ctx = create_element(parser, fragment_ctx);
parser->_parser_state->_fragment_ctx->v.element.tag_namespace =
fragment_namespace;
// 4
if (fragment_namespace == GUMBO_NAMESPACE_HTML) {
// Non-HTML namespaces always start in the DATA state.
switch (fragment_ctx) {
case GUMBO_TAG_TITLE:
case GUMBO_TAG_TEXTAREA:
gumbo_tokenizer_set_state(parser, GUMBO_LEX_RCDATA);
break;
case GUMBO_TAG_STYLE:
case GUMBO_TAG_XMP:
case GUMBO_TAG_IFRAME:
case GUMBO_TAG_NOEMBED:
case GUMBO_TAG_NOFRAMES:
gumbo_tokenizer_set_state(parser, GUMBO_LEX_RAWTEXT);
break;
case GUMBO_TAG_SCRIPT:
gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
break;
case GUMBO_TAG_NOSCRIPT:
/* scripting is disabled in Gumbo, so leave the tokenizer
* in the default data state */
break;
case GUMBO_TAG_PLAINTEXT:
gumbo_tokenizer_set_state(parser, GUMBO_LEX_PLAINTEXT);
break;
default:
/* default data state */
break;
}
}
// 5. 6. 7.
root = insert_element_of_tag_type(
parser, GUMBO_TAG_HTML, GUMBO_INSERTION_IMPLIED);
parser->_output->root = root;
// 8.
if (fragment_ctx == GUMBO_TAG_TEMPLATE) {
push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
}
// 10.
reset_insertion_mode_appropriately(parser);
}
GumboOutput* gumbo_parse(const char* buffer) {
return gumbo_parse_with_options(
&kGumboDefaultOptions, buffer, strlen(buffer));
}
GumboOutput* gumbo_parse_with_options(
const GumboOptions* options, const char* buffer, size_t length) {
GumboParser parser;
parser._options = options;
output_init(&parser);
gumbo_tokenizer_state_init(&parser, buffer, length);
parser_state_init(&parser);
if (options->fragment_context != GUMBO_TAG_LAST) {
fragment_parser_init(
&parser, options->fragment_context, options->fragment_namespace);
}
GumboParserState* state = parser._parser_state;
gumbo_debug("Parsing %.*s.\n", length, buffer);
// Sanity check so that infinite loops die with an assertion failure instead
// of hanging the process before we ever get an error.
int loop_count = 0;
GumboToken token;
bool has_error = false;
do {
if (state->_reprocess_current_token) {
state->_reprocess_current_token = false;
} else {
GumboNode* current_node = get_current_node(&parser);
gumbo_tokenizer_set_is_current_node_foreign(&parser,
current_node &&
current_node->v.element.tag_namespace != GUMBO_NAMESPACE_HTML);
has_error = !gumbo_lex(&parser, &token) || has_error;
}
const char* token_type = "text";
switch (token.type) {
case GUMBO_TOKEN_DOCTYPE:
token_type = "doctype";
break;
case GUMBO_TOKEN_START_TAG:
token_type = gumbo_normalized_tagname(token.v.start_tag.tag);
break;
case GUMBO_TOKEN_END_TAG:
token_type = gumbo_normalized_tagname(token.v.end_tag);
break;
case GUMBO_TOKEN_COMMENT:
token_type = "comment";
break;
default:
break;
}
gumbo_debug("Handling %s token @%d:%d in state %d.\n", (char*) token_type,
token.position.line, token.position.column, state->_insertion_mode);
state->_current_token = &token;
state->_self_closing_flag_acknowledged =
!(token.type == GUMBO_TOKEN_START_TAG &&
token.v.start_tag.is_self_closing);
has_error = !handle_token(&parser, &token) || has_error;
// Check for memory leaks when ownership is transferred from start tag
// tokens to nodes.
assert(state->_reprocess_current_token ||
token.type != GUMBO_TOKEN_START_TAG ||
token.v.start_tag.attributes.data == NULL);
if (!state->_self_closing_flag_acknowledged) {
GumboError* error = parser_add_parse_error(&parser, &token);
if (error) {
error->type = GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG;
}
}
++loop_count;
assert(loop_count < 1000000000);
} while ((token.type != GUMBO_TOKEN_EOF || state->_reprocess_current_token) &&
!(options->stop_on_first_error && has_error));
finish_parsing(&parser);
// For API uniformity reasons, if the doctype still has nulls, convert them to
// empty strings.
GumboDocument* doc_type = &parser._output->document->v.document;
if (doc_type->name == NULL) {
doc_type->name = gumbo_copy_stringz(&parser, "");
}
if (doc_type->public_identifier == NULL) {
doc_type->public_identifier = gumbo_copy_stringz(&parser, "");
}
if (doc_type->system_identifier == NULL) {
doc_type->system_identifier = gumbo_copy_stringz(&parser, "");
}
parser_state_destroy(&parser);
gumbo_tokenizer_state_destroy(&parser);
return parser._output;
}
void gumbo_destroy_node(GumboOptions* options, GumboNode* node) {
// Need a dummy GumboParser because the allocator comes along with the
// options object.
GumboParser parser;
parser._options = options;
destroy_node(&parser, node);
}
void gumbo_destroy_output(const GumboOptions* options, GumboOutput* output) {
// Need a dummy GumboParser because the allocator comes along with the
// options object.
GumboParser parser;
parser._options = options;
destroy_node(&parser, output->document);
for (unsigned int i = 0; i < output->errors.length; ++i) {
gumbo_error_destroy(&parser, output->errors.data[i]);
}
gumbo_vector_destroy(&parser, &output->errors);
gumbo_parser_deallocate(&parser, output);
}