nokogumbo 1.5.0 → 2.0.5

data/gumbo-parser/src/error.h

@@ -1,32 +1,13 @@
-// 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)
-//
-// Error types, enums, and handling functions.
-
 #ifndef GUMBO_ERROR_H_
 #define GUMBO_ERROR_H_
-#ifdef _MSC_VER
-#define _CRT_SECURE_NO_WARNINGS
-#endif
+
 #include <stdint.h>
 
 #include "gumbo.h"
 #include "insertion_mode.h"
 #include "string_buffer.h"
 #include "token_type.h"
+#include "tokenizer_states.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -35,84 +16,66 @@ extern "C" {
 struct GumboInternalParser;
 
 typedef enum {
+  // Defined errors.
+  // https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+  GUMBO_ERR_ABRUPT_CLOSING_OF_EMPTY_COMMENT,
+  GUMBO_ERR_ABRUPT_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_ABRUPT_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE,
+  GUMBO_ERR_CDATA_IN_HTML_CONTENT,
+  GUMBO_ERR_CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE,
+  GUMBO_ERR_CONTROL_CHARACTER_IN_INPUT_STREAM,
+  GUMBO_ERR_CONTROL_CHARACTER_REFERENCE,
+  GUMBO_ERR_END_TAG_WITH_ATTRIBUTES,
+  GUMBO_ERR_DUPLICATE_ATTRIBUTE,
+  GUMBO_ERR_END_TAG_WITH_TRAILING_SOLIDUS,
+  GUMBO_ERR_EOF_BEFORE_TAG_NAME,
+  GUMBO_ERR_EOF_IN_CDATA,
+  GUMBO_ERR_EOF_IN_COMMENT,
+  GUMBO_ERR_EOF_IN_DOCTYPE,
+  GUMBO_ERR_EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT,
+  GUMBO_ERR_EOF_IN_TAG,
+  GUMBO_ERR_INCORRECTLY_CLOSED_COMMENT,
+  GUMBO_ERR_INCORRECTLY_OPENED_COMMENT,
+  GUMBO_ERR_INVALID_CHARACTER_SEQUENCE_AFTER_DOCTYPE_NAME,
+  GUMBO_ERR_INVALID_FIRST_CHARACTER_OF_TAG_NAME,
+  GUMBO_ERR_MISSING_ATTRIBUTE_VALUE,
+  GUMBO_ERR_MISSING_DOCTYPE_NAME,
+  GUMBO_ERR_MISSING_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_MISSING_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_MISSING_END_TAG_NAME,
+  GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE,
+  GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_PUBLIC_KEYWORD,
+  GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_SYSTEM_KEYWORD,
+  GUMBO_ERR_MISSING_WHITESPACE_BEFORE_DOCTYPE_NAME,
+  GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_ATTRIBUTES,
+  GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS,
+  GUMBO_ERR_NESTED_COMMENT,
+  GUMBO_ERR_NONCHARACTER_CHARACTER_REFERENCE,
+  GUMBO_ERR_NONCHARACTER_IN_INPUT_STREAM,
+  GUMBO_ERR_NON_VOID_HTML_ELEMENT_START_TAG_WITH_TRAILING_SOLIDUS,
+  GUMBO_ERR_NULL_CHARACTER_REFERENCE,
+  GUMBO_ERR_SURROGATE_CHARACTER_REFERENCE,
+  GUMBO_ERR_SURROGATE_IN_INPUT_STREAM,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
+  GUMBO_ERR_UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME,
+  GUMBO_ERR_UNEXPECTED_NULL_CHARACTER,
+  GUMBO_ERR_UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME,
+  GUMBO_ERR_UNEXPECTED_SOLIDUS_IN_TAG,
+  GUMBO_ERR_UNKNOWN_NAMED_CHARACTER_REFERENCE,
+
+  // Encoding errors.
   GUMBO_ERR_UTF8_INVALID,
   GUMBO_ERR_UTF8_TRUNCATED,
-  GUMBO_ERR_UTF8_NULL,
-  GUMBO_ERR_NUMERIC_CHAR_REF_NO_DIGITS,
-  GUMBO_ERR_NUMERIC_CHAR_REF_WITHOUT_SEMICOLON,
-  GUMBO_ERR_NUMERIC_CHAR_REF_INVALID,
-  GUMBO_ERR_NAMED_CHAR_REF_WITHOUT_SEMICOLON,
-  GUMBO_ERR_NAMED_CHAR_REF_INVALID,
-  GUMBO_ERR_TAG_STARTS_WITH_QUESTION,
-  GUMBO_ERR_TAG_EOF,
-  GUMBO_ERR_TAG_INVALID,
-  GUMBO_ERR_CLOSE_TAG_EMPTY,
-  GUMBO_ERR_CLOSE_TAG_EOF,
-  GUMBO_ERR_CLOSE_TAG_INVALID,
-  GUMBO_ERR_SCRIPT_EOF,
-  GUMBO_ERR_ATTR_NAME_EOF,
-  GUMBO_ERR_ATTR_NAME_INVALID,
-  GUMBO_ERR_ATTR_DOUBLE_QUOTE_EOF,
-  GUMBO_ERR_ATTR_SINGLE_QUOTE_EOF,
-  GUMBO_ERR_ATTR_UNQUOTED_EOF,
-  GUMBO_ERR_ATTR_UNQUOTED_RIGHT_BRACKET,
-  GUMBO_ERR_ATTR_UNQUOTED_EQUALS,
-  GUMBO_ERR_ATTR_AFTER_EOF,
-  GUMBO_ERR_ATTR_AFTER_INVALID,
-  GUMBO_ERR_DUPLICATE_ATTR,
-  GUMBO_ERR_SOLIDUS_EOF,
-  GUMBO_ERR_SOLIDUS_INVALID,
-  GUMBO_ERR_DASHES_OR_DOCTYPE,
-  GUMBO_ERR_COMMENT_EOF,
-  GUMBO_ERR_COMMENT_INVALID,
-  GUMBO_ERR_COMMENT_BANG_AFTER_DOUBLE_DASH,
-  GUMBO_ERR_COMMENT_DASH_AFTER_DOUBLE_DASH,
-  GUMBO_ERR_COMMENT_SPACE_AFTER_DOUBLE_DASH,
-  GUMBO_ERR_COMMENT_END_BANG_EOF,
-  GUMBO_ERR_DOCTYPE_EOF,
-  GUMBO_ERR_DOCTYPE_INVALID,
-  GUMBO_ERR_DOCTYPE_SPACE,
-  GUMBO_ERR_DOCTYPE_RIGHT_BRACKET,
-  GUMBO_ERR_DOCTYPE_SPACE_OR_RIGHT_BRACKET,
-  GUMBO_ERR_DOCTYPE_END,
+
+  // Generic parser error.
   GUMBO_ERR_PARSER,
-  GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG,
 } GumboErrorType;
 
-// Additional data for duplicated attributes.
-typedef struct GumboInternalDuplicateAttrError {
-  // The name of the attribute.  Owned by this struct.
-  const char* name;
-
-  // The (0-based) index within the attributes vector of the original
-  // occurrence.
-  unsigned int original_index;
-
-  // The (0-based) index where the new occurrence would be.
-  unsigned int new_index;
-} GumboDuplicateAttrError;
-
-// A simplified representation of the tokenizer state, designed to be more
-// useful to clients of this library than the internal representation.  This
-// condenses the actual states used in the tokenizer state machine into a few
-// values that will be familiar to users of HTML.
-typedef enum {
-  GUMBO_ERR_TOKENIZER_DATA,
-  GUMBO_ERR_TOKENIZER_CHAR_REF,
-  GUMBO_ERR_TOKENIZER_RCDATA,
-  GUMBO_ERR_TOKENIZER_RAWTEXT,
-  GUMBO_ERR_TOKENIZER_PLAINTEXT,
-  GUMBO_ERR_TOKENIZER_SCRIPT,
-  GUMBO_ERR_TOKENIZER_TAG,
-  GUMBO_ERR_TOKENIZER_SELF_CLOSING_TAG,
-  GUMBO_ERR_TOKENIZER_ATTR_NAME,
-  GUMBO_ERR_TOKENIZER_ATTR_VALUE,
-  GUMBO_ERR_TOKENIZER_MARKUP_DECLARATION,
-  GUMBO_ERR_TOKENIZER_COMMENT,
-  GUMBO_ERR_TOKENIZER_DOCTYPE,
-  GUMBO_ERR_TOKENIZER_CDATA,
-} GumboTokenizerErrorState;
-
 // Additional data for tokenizer errors.
 // This records the current state and codepoint encountered - this is usually
 // enough to reconstruct what went wrong and provide a friendly error message.
@@ -121,7 +84,7 @@ typedef struct GumboInternalTokenizerError {
   int codepoint;
 
   // The state that the tokenizer was in at the time.
-  GumboTokenizerErrorState state;
+  GumboTokenizerEnum state;
 } GumboTokenizerError;
 
 // Additional data for parse errors.
@@ -129,61 +92,43 @@ typedef struct GumboInternalParserError {
   // The type of input token that resulted in this error.
   GumboTokenType input_type;
 
-  // The HTML tag of the input token.  TAG_UNKNOWN if this was not a tag token.
+  // The HTML tag of the input token. TAG_UNKNOWN if this was not a tag token.
   GumboTag input_tag;
 
   // The insertion mode that the parser was in at the time.
   GumboInsertionMode parser_state;
 
-  // The tag stack at the point of the error.  Note that this is an GumboVector
+  // The tag stack at the point of the error. Note that this is an GumboVector
   // of GumboTag's *stored by value* - cast the void* to an GumboTag directly to
   // get at the tag.
   GumboVector /* GumboTag */ tag_stack;
 } GumboParserError;
 
 // The overall error struct representing an error in decoding/tokenizing/parsing
-// the HTML.  This contains an enumerated type flag, a source position, and then
+// the HTML. This contains an enumerated type flag, a source position, and then
 // a union of fields containing data specific to the error.
-typedef struct GumboInternalError {
+struct GumboInternalError {
   // The type of error.
   GumboErrorType type;
 
   // The position within the source file where the error occurred.
   GumboSourcePosition position;
 
-  // A pointer to the byte within the original source file text where the error
-  // occurred (note that this is not the same as position.offset, as that gives
-  // character-based instead of byte-based offsets).
-  const char* original_text;
+  // The piece of text that caused the error.
+  GumboStringPiece original_text;
 
   // Type-specific error information.
   union {
-    // The code point we encountered, for:
-    // * GUMBO_ERR_UTF8_INVALID
-    // * GUMBO_ERR_UTF8_TRUNCATED
-    // * GUMBO_ERR_NUMERIC_CHAR_REF_WITHOUT_SEMICOLON
-    // * GUMBO_ERR_NUMERIC_CHAR_REF_INVALID
-    uint64_t codepoint;
-
     // Tokenizer errors.
     GumboTokenizerError tokenizer;
 
-    // Short textual data, for:
-    // * GUMBO_ERR_NAMED_CHAR_REF_WITHOUT_SEMICOLON
-    // * GUMBO_ERR_NAMED_CHAR_REF_INVALID
-    GumboStringPiece text;
-
-    // Duplicate attribute data, for GUMBO_ERR_DUPLICATE_ATTR.
-    GumboDuplicateAttrError duplicate_attr;
-
-    // Parser state, for GUMBO_ERR_PARSER and
-    // GUMBO_ERR_UNACKNOWLEDGE_SELF_CLOSING_TAG.
-    struct GumboInternalParserError parser;
+    // Parser errors.
+    GumboParserError parser;
   } v;
-} GumboError;
+};
 
 // Adds a new error to the parser's error list, and returns a pointer to it so
-// that clients can fill out the rest of its fields.  May return NULL if we're
+// that clients can fill out the rest of its fields. May return NULL if we're
 // already over the max_errors field specified in GumboOptions.
 GumboError* gumbo_add_error(struct GumboInternalParser* parser);
 
@@ -194,32 +139,10 @@ void gumbo_init_errors(struct GumboInternalParser* errors);
 void gumbo_destroy_errors(struct GumboInternalParser* errors);
 
 // Frees the memory used for a single GumboError.
-void gumbo_error_destroy(struct GumboInternalParser* parser, GumboError* error);
-
-// Prints an error to a string.  This fills an empty GumboStringBuffer with a
-// freshly-allocated buffer containing the error message text.  The caller is
-// responsible for deleting the buffer.  (Note that the buffer is allocated with
-// the allocator specified in the GumboParser config and hence should be freed
-// by gumbo_parser_deallocate().)
-void gumbo_error_to_string(struct GumboInternalParser* parser,
-    const GumboError* error, GumboStringBuffer* output);
-
-// Prints a caret diagnostic to a string.  This fills an empty GumboStringBuffer
-// with a freshly-allocated buffer containing the error message text.  The
-// caller is responsible for deleting the buffer.  (Note that the buffer is
-// allocated with the allocator specified in the GumboParser config and hence
-// should be freed by gumbo_parser_deallocate().)
-void gumbo_caret_diagnostic_to_string(struct GumboInternalParser* parser,
-    const GumboError* error, const char* source_text,
-    GumboStringBuffer* output);
-
-// Like gumbo_caret_diagnostic_to_string, but prints the text to stdout instead
-// of writing to a string.
-void gumbo_print_caret_diagnostic(struct GumboInternalParser* parser,
-    const GumboError* error, const char* source_text);
+void gumbo_error_destroy(GumboError* error);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // GUMBO_ERROR_H_
+#endif // GUMBO_ERROR_H_

data/gumbo-parser/src/foreign_attrs.c

@@ -0,0 +1,104 @@
+/* ANSI-C code produced by gperf version 3.1 */
+/* Command-line: gperf -m100 -n lib/foreign_attrs.gperf  */
+/* Computed positions: -k'2,8' */
+/* Filtered by: mk/gperf-filter.sed */
+
+#include "replacement.h"
+#include "macros.h"
+#include <string.h>
+
+#define TOTAL_KEYWORDS 11
+#define MIN_WORD_LENGTH 5
+#define MAX_WORD_LENGTH 13
+#define MIN_HASH_VALUE 0
+#define MAX_HASH_VALUE 10
+/* maximum key range = 11, duplicates = 0 */
+
+static inline unsigned int
+hash (register const char *str, register size_t len)
+{
+  static const unsigned char asso_values[] =
+    {
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11,  2,
+      11, 10, 11,  9,  7,  6, 11, 11,  1,  0,
+      11,  5, 11, 11,  4, 11, 11, 11, 11, 11,
+      11,  3, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+      11, 11, 11, 11, 11, 11
+    };
+  register unsigned int hval = 0;
+
+  switch (len)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[7]];
+      /*FALLTHROUGH*/
+      case 7:
+      case 6:
+      case 5:
+      case 4:
+      case 3:
+      case 2:
+        hval += asso_values[(unsigned char)str[1]];
+        break;
+    }
+  return hval;
+}
+
+const ForeignAttrReplacement *
+gumbo_get_foreign_attr_replacement (register const char *str, register size_t len)
+{
+  static const unsigned char lengthtable[] =
+    {
+       5, 11,  9, 13, 10, 10, 10, 11, 10,  8,  8
+    };
+  static const ForeignAttrReplacement wordlist[] =
+    {
+      {"xmlns", "xmlns", GUMBO_ATTR_NAMESPACE_XMLNS},
+      {"xmlns:xlink", "xlink", GUMBO_ATTR_NAMESPACE_XMLNS},
+      {"xml:space", "space", GUMBO_ATTR_NAMESPACE_XML},
+      {"xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:type", "type", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:title", "title", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:show", "show", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML},
+      {"xml:base", "base", GUMBO_ATTR_NAMESPACE_XML}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register unsigned int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE)
+        if (len == lengthtable[key])
+          {
+            register const char *s = wordlist[key].from;
+
+            if (s && *str == *s && !memcmp (str + 1, s + 1, len - 1))
+              return &wordlist[key];
+          }
+    }
+  return 0;
+}

data/gumbo-parser/src/gumbo.h

@@ -1,51 +1,33 @@
-// 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)
-//
-// We use Gumbo as a prefix for types, gumbo_ as a prefix for functions, and
-// GUMBO_ as a prefix for enum constants (static constants get the Google-style
-// kGumbo prefix).
+// Copyright 2010 Google Inc.
+// Copyright 2018 Craig Barnes.
+// Licensed under the Apache License, version 2.0.
+
+// We use Gumbo as a prefix for types, gumbo_ as a prefix for functions,
+// GUMBO_ as a prefix for enum constants and kGumbo as a prefix for
+// static constants
 
 /**
  * @file
  * @mainpage Gumbo HTML Parser
  *
- * This provides a conformant, no-dependencies implementation of the HTML5
- * parsing algorithm.  It supports only UTF8; if you need to parse a different
- * encoding, run a preprocessing step to convert to UTF8.  It returns a parse
- * tree made of the structs in this file.
+ * This provides a conformant, no-dependencies implementation of the
+ * [HTML5] parsing algorithm. It supports only UTF-8 -- if you need
+ * to parse a different encoding, run a preprocessing step to convert
+ * to UTF-8. It returns a parse tree made of the structs in this file.
  *
  * Example:
  * @code
  *    GumboOutput* output = gumbo_parse(input);
  *    do_something_with_doctype(output->document);
  *    do_something_with_html_tree(output->root);
- *    gumbo_destroy_output(&options, output);
+ *    gumbo_destroy_output(output);
  * @endcode
- * HTML5 Spec:
  *
- * http://www.whatwg.org/specs/web-apps/current-work/multipage/syntax.html
+ * [HTML5]: https://html.spec.whatwg.org/multipage/
  */
 
-#ifndef GUMBO_GUMBO_H_
-#define GUMBO_GUMBO_H_
-
-#ifdef _MSC_VER
-#define _CRT_SECURE_NO_WARNINGS
-#define fileno _fileno
-#endif
+#ifndef GUMBO_H
+#define GUMBO_H
 
 #include <stdbool.h>
 #include <stddef.h>
@@ -55,73 +37,77 @@ extern "C" {
 #endif
 
 /**
- * A struct representing a character position within the original text buffer.
- * Line and column numbers are 1-based and offsets are 0-based, which matches
- * how most editors and command-line tools work.  Also, columns measure
- * positions in terms of characters while offsets measure by bytes; this is
- * because the offset field is often used to pull out a particular region of
- * text (which in most languages that bind to C implies pointer arithmetic on a
- * buffer of bytes), while the column field is often used to reference a
- * particular column on a printable display, which nowadays is usually UTF-8.
+ * A struct representing a character position within the original text
+ * buffer. Line and column numbers are 1-based and offsets are 0-based,
+ * which matches how most editors and command-line tools work.
  */
 typedef struct {
-  unsigned int line;
-  unsigned int column;
-  unsigned int offset;
+  size_t line;
+  size_t column;
+  size_t offset;
 } GumboSourcePosition;
 
 /**
- * A SourcePosition used for elements that have no source position, i.e.
- * parser-inserted elements.
- */
-extern const GumboSourcePosition kGumboEmptySourcePosition;
-
-/**
- * A struct representing a string or part of a string.  Strings within the
- * parser are represented by a char* and a length; the char* points into
- * an existing data buffer owned by some other code (often the original input).
- * GumboStringPieces are assumed (by convention) to be immutable, because they
- * may share data.  Use GumboStringBuffer if you need to construct a string.
- * Clients should assume that it is not NUL-terminated, and should always use
- * explicit lengths when manipulating them.
+ * A struct representing a string or part of a string. Strings within
+ * the parser are represented by a `char*` and a length; the `char*`
+ * points into an existing data buffer owned by some other code (often
+ * the original input). `GumboStringPiece`s are assumed (by convention)
+ * to be immutable, because they may share data. Clients should assume
+ * that it is not NUL-terminated and should always use explicit lengths
+ * when manipulating them.
  */
 typedef struct {
-  /** A pointer to the beginning of the string.  NULL iff length == 0. */
+  /** A pointer to the beginning of the string. `NULL` if `length == 0`. */
   const char* data;
 
-  /** The length of the string fragment, in bytes.  May be zero. */
+  /** The length of the string fragment, in bytes (may be zero). */
   size_t length;
 } GumboStringPiece;
 
+#define GUMBO_EMPTY_STRING_INIT { .data = NULL, .length = 0 }
 /** A constant to represent a 0-length null string. */
-extern const GumboStringPiece kGumboEmptyString;
+#define kGumboEmptyString (const GumboStringPiece)GUMBO_EMPTY_STRING_INIT
 
 /**
- * Compares two GumboStringPieces, and returns true if they're equal or false
- * otherwise.
+ * Compares two `GumboStringPiece`s, and returns `true` if they're
+ * equal or `false` otherwise.
  */
-bool gumbo_string_equals(
-    const GumboStringPiece* str1, const GumboStringPiece* str2);
+bool gumbo_string_equals (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+);
 
 /**
- * Compares two GumboStringPieces ignoring case, and returns true if they're
- * equal or false otherwise.
+ * Compares two `GumboStringPiece`s, ignoring case, and returns `true`
+ * if they're equal or `false` otherwise.
  */
-bool gumbo_string_equals_ignore_case(
-    const GumboStringPiece* str1, const GumboStringPiece* str2);
+bool gumbo_string_equals_ignore_case (
+  const GumboStringPiece* str1,
+  const GumboStringPiece* str2
+);
 
 /**
- * A simple vector implementation.  This stores a pointer to a data array and a
- * length.  All elements are stored as void*; client code must cast to the
- * appropriate type.  Overflows upon addition result in reallocation of the data
- * array, with the size doubling to maintain O(1) amortized cost.  There is no
- * removal function, as this isn't needed for any of the operations within this
- * library.  Iteration can be done through inspecting the structure directly in
- * a for-loop.
+ * Check if the first `GumboStringPiece` is a prefix of the second, ignoring
+ * case.
+ */
+bool gumbo_string_prefix_ignore_case (
+  const GumboStringPiece* prefix,
+  const GumboStringPiece* str
+);
+
+/**
+ * A simple vector implementation. This stores a pointer to a data array
+ * and a length. All elements are stored as `void*`; client code must
+ * cast to the appropriate type. Overflows upon addition result in
+ * reallocation of the data array, with the size doubling to maintain
+ * `O(1)` amortized cost. There is no removal function, as this isn't
+ * needed for any of the operations within this library. Iteration can
+ * be done through inspecting the structure directly in a `for` loop.
  */
 typedef struct {
-  /** Data elements.  This points to a dynamically-allocated array of capacity
-   * elements, each a void* to the element itself.
+  /**
+   * Data elements. This points to a dynamically-allocated array of
+   * `capacity` elements, each a `void*` to the element itself.
    */
   void** data;
 
@@ -132,82 +118,230 @@ typedef struct {
   unsigned int capacity;
 } GumboVector;
 
-/** An empty (0-length, 0-capacity) GumboVector. */
-extern const GumboVector kGumboEmptyVector;
+# define GUMBO_EMPTY_VECTOR_INIT { .data = NULL, .length = 0, .capacity = 0 }
+/** An empty (0-length, 0-capacity) `GumboVector`. */
+#define kGumboEmptyVector (const GumboVector)GUMBO_EMPTY_VECTOR_INIT
 
 /**
- * Returns the first index at which an element appears in this vector (testing
- * by pointer equality), or -1 if it never does.
+ * Returns the first index at which an element appears in this vector
+ * (testing by pointer equality), or `-1` if it never does.
  */
 int gumbo_vector_index_of(GumboVector* vector, const void* element);
 
 /**
- * An enum for all the tags defined in the HTML5 standard.  These correspond to
- * the tag names themselves.  Enum constants exist only for tags which appear in
- * the spec itself (or for tags with special handling in the SVG and MathML
- * namespaces); any other tags appear as GUMBO_TAG_UNKNOWN and the actual tag
- * name can be obtained through original_tag.
+ * An `enum` for all the tags defined in the HTML5 standard. These
+ * correspond to the tag names themselves. Enum constants exist only
+ * for tags that appear in the spec itself (or for tags with special
+ * handling in the SVG and MathML namespaces). Any other tags appear
+ * as `GUMBO_TAG_UNKNOWN` and the actual tag name can be obtained
+ * through `original_tag`.
  *
- * This is mostly for API convenience, so that clients of this library don't
- * need to perform a strcasecmp to find the normalized tag name.  It also has
- * efficiency benefits, by letting the parser work with enums instead of
- * strings.
+ * This is mostly for API convenience, so that clients of this library
+ * don't need to perform a `strcasecmp` to find the normalized tag
+ * name. It also has efficiency benefits, by letting the parser work
+ * with enums instead of strings.
  */
 typedef enum {
-// Load all the tags from an external source, generated from tag.in.
-#include "tag_enum.h"
-  // Used for all tags that don't have special handling in HTML.  Add new tags
-  // to the end of tag.in so as to preserve backwards-compatibility.
+  GUMBO_TAG_HTML,
+  GUMBO_TAG_HEAD,
+  GUMBO_TAG_TITLE,
+  GUMBO_TAG_BASE,
+  GUMBO_TAG_LINK,
+  GUMBO_TAG_META,
+  GUMBO_TAG_STYLE,
+  GUMBO_TAG_SCRIPT,
+  GUMBO_TAG_NOSCRIPT,
+  GUMBO_TAG_TEMPLATE,
+  GUMBO_TAG_BODY,
+  GUMBO_TAG_ARTICLE,
+  GUMBO_TAG_SECTION,
+  GUMBO_TAG_NAV,
+  GUMBO_TAG_ASIDE,
+  GUMBO_TAG_H1,
+  GUMBO_TAG_H2,
+  GUMBO_TAG_H3,
+  GUMBO_TAG_H4,
+  GUMBO_TAG_H5,
+  GUMBO_TAG_H6,
+  GUMBO_TAG_HGROUP,
+  GUMBO_TAG_HEADER,
+  GUMBO_TAG_FOOTER,
+  GUMBO_TAG_ADDRESS,
+  GUMBO_TAG_P,
+  GUMBO_TAG_HR,
+  GUMBO_TAG_PRE,
+  GUMBO_TAG_BLOCKQUOTE,
+  GUMBO_TAG_OL,
+  GUMBO_TAG_UL,
+  GUMBO_TAG_LI,
+  GUMBO_TAG_DL,
+  GUMBO_TAG_DT,
+  GUMBO_TAG_DD,
+  GUMBO_TAG_FIGURE,
+  GUMBO_TAG_FIGCAPTION,
+  GUMBO_TAG_MAIN,
+  GUMBO_TAG_DIV,
+  GUMBO_TAG_A,
+  GUMBO_TAG_EM,
+  GUMBO_TAG_STRONG,
+  GUMBO_TAG_SMALL,
+  GUMBO_TAG_S,
+  GUMBO_TAG_CITE,
+  GUMBO_TAG_Q,
+  GUMBO_TAG_DFN,
+  GUMBO_TAG_ABBR,
+  GUMBO_TAG_DATA,
+  GUMBO_TAG_TIME,
+  GUMBO_TAG_CODE,
+  GUMBO_TAG_VAR,
+  GUMBO_TAG_SAMP,
+  GUMBO_TAG_KBD,
+  GUMBO_TAG_SUB,
+  GUMBO_TAG_SUP,
+  GUMBO_TAG_I,
+  GUMBO_TAG_B,
+  GUMBO_TAG_U,
+  GUMBO_TAG_MARK,
+  GUMBO_TAG_RUBY,
+  GUMBO_TAG_RT,
+  GUMBO_TAG_RP,
+  GUMBO_TAG_BDI,
+  GUMBO_TAG_BDO,
+  GUMBO_TAG_SPAN,
+  GUMBO_TAG_BR,
+  GUMBO_TAG_WBR,
+  GUMBO_TAG_INS,
+  GUMBO_TAG_DEL,
+  GUMBO_TAG_IMAGE,
+  GUMBO_TAG_IMG,
+  GUMBO_TAG_IFRAME,
+  GUMBO_TAG_EMBED,
+  GUMBO_TAG_OBJECT,
+  GUMBO_TAG_PARAM,
+  GUMBO_TAG_VIDEO,
+  GUMBO_TAG_AUDIO,
+  GUMBO_TAG_SOURCE,
+  GUMBO_TAG_TRACK,
+  GUMBO_TAG_CANVAS,
+  GUMBO_TAG_MAP,
+  GUMBO_TAG_AREA,
+  GUMBO_TAG_MATH,
+  GUMBO_TAG_MI,
+  GUMBO_TAG_MO,
+  GUMBO_TAG_MN,
+  GUMBO_TAG_MS,
+  GUMBO_TAG_MTEXT,
+  GUMBO_TAG_MGLYPH,
+  GUMBO_TAG_MALIGNMARK,
+  GUMBO_TAG_ANNOTATION_XML,
+  GUMBO_TAG_SVG,
+  GUMBO_TAG_FOREIGNOBJECT,
+  GUMBO_TAG_DESC,
+  GUMBO_TAG_TABLE,
+  GUMBO_TAG_CAPTION,
+  GUMBO_TAG_COLGROUP,
+  GUMBO_TAG_COL,
+  GUMBO_TAG_TBODY,
+  GUMBO_TAG_THEAD,
+  GUMBO_TAG_TFOOT,
+  GUMBO_TAG_TR,
+  GUMBO_TAG_TD,
+  GUMBO_TAG_TH,
+  GUMBO_TAG_FORM,
+  GUMBO_TAG_FIELDSET,
+  GUMBO_TAG_LEGEND,
+  GUMBO_TAG_LABEL,
+  GUMBO_TAG_INPUT,
+  GUMBO_TAG_BUTTON,
+  GUMBO_TAG_SELECT,
+  GUMBO_TAG_DATALIST,
+  GUMBO_TAG_OPTGROUP,
+  GUMBO_TAG_OPTION,
+  GUMBO_TAG_TEXTAREA,
+  GUMBO_TAG_KEYGEN,
+  GUMBO_TAG_OUTPUT,
+  GUMBO_TAG_PROGRESS,
+  GUMBO_TAG_METER,
+  GUMBO_TAG_DETAILS,
+  GUMBO_TAG_SUMMARY,
+  GUMBO_TAG_MENU,
+  GUMBO_TAG_MENUITEM,
+  GUMBO_TAG_APPLET,
+  GUMBO_TAG_ACRONYM,
+  GUMBO_TAG_BGSOUND,
+  GUMBO_TAG_DIR,
+  GUMBO_TAG_FRAME,
+  GUMBO_TAG_FRAMESET,
+  GUMBO_TAG_NOFRAMES,
+  GUMBO_TAG_LISTING,
+  GUMBO_TAG_XMP,
+  GUMBO_TAG_NEXTID,
+  GUMBO_TAG_NOEMBED,
+  GUMBO_TAG_PLAINTEXT,
+  GUMBO_TAG_RB,
+  GUMBO_TAG_STRIKE,
+  GUMBO_TAG_BASEFONT,
+  GUMBO_TAG_BIG,
+  GUMBO_TAG_BLINK,
+  GUMBO_TAG_CENTER,
+  GUMBO_TAG_FONT,
+  GUMBO_TAG_MARQUEE,
+  GUMBO_TAG_MULTICOL,
+  GUMBO_TAG_NOBR,
+  GUMBO_TAG_SPACER,
+  GUMBO_TAG_TT,
+  GUMBO_TAG_RTC,
+  GUMBO_TAG_DIALOG,
+  // Used for all tags that don't have special handling in HTML.
   GUMBO_TAG_UNKNOWN,
   // A marker value to indicate the end of the enum, for iterating over it.
-  // Also used as the terminator for varargs functions that take tags.
   GUMBO_TAG_LAST,
 } GumboTag;
 
 /**
- * Returns the normalized (usually all-lowercased, except for foreign content)
- * tag name for an GumboTag enum.  Return value is static data owned by the
- * library.
+ * Returns the normalized (all lower case) tag name for a `GumboTag` enum. The
+ * return value is static data owned by the library.
  */
 const char* gumbo_normalized_tagname(GumboTag tag);
 
 /**
- * Extracts the tag name from the original_text field of an element or token by
- * stripping off </> characters and attributes and adjusting the passed-in
- * GumboStringPiece appropriately.  The tag name is in the original case and
- * shares a buffer with the original text, to simplify memory management.
- * Behavior is undefined if a string-piece that doesn't represent an HTML tag
- * (<tagname> or </tagname>) is passed in.  If the string piece is completely
- * empty (NULL data pointer), then this function will exit successfully as a
- * no-op.
+ * Extracts the tag name from the `original_text` field of an element
+ * or token by stripping off `</>` characters and attributes and
+ * adjusting the passed-in `GumboStringPiece` appropriately. The tag
+ * name is in the original case and shares a buffer with the original
+ * text, to simplify memory management. Behavior is undefined if a
+ * string piece that doesn't represent an HTML tag (`<tagname>` or
+ * `</tagname>`) is passed in. If the string piece is completely
+ * empty (`NULL` data pointer), then this function will exit
+ * successfully as a no-op.
  */
 void gumbo_tag_from_original_text(GumboStringPiece* text);
 
 /**
- * Fixes the case of SVG elements that are not all lowercase.
- * http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#parsing-main-inforeign
- * This is not done at parse time because there's no place to store a mutated
- * tag name.  tag_name is an enum (which will be TAG_UNKNOWN for most SVG tags
- * without special handling), while original_tag_name is a pointer into the
- * original buffer.  Instead, we provide this helper function that clients can
- * use to rename SVG tags as appropriate.
- * Returns the case-normalized SVG tagname if a replacement is found, or NULL if
- * no normalization is called for.  The return value is static data and owned by
- * the library.
+ * Fixes the case of SVG elements that are not all lowercase. This is
+ * not done at parse time because there's no place to store a mutated
+ * tag name. `tag_name` is an enum (which will be `TAG_UNKNOWN` for most
+ * SVG tags without special handling), while `original_tag_name` is a
+ * pointer into the original buffer. Instead, we provide this helper
+ * function that clients can use to rename SVG tags as appropriate.
+ * Returns the case-normalized SVG tagname if a replacement is found, or
+ * `NULL` if no normalization is called for. The return value is static
+ * data and owned by the library.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
  */
 const char* gumbo_normalize_svg_tagname(const GumboStringPiece* tagname);
 
 /**
- * Converts a tag name string (which may be in upper or mixed case) to a tag
- * enum. The `tag` version expects `tagname` to be NULL-terminated
+ * Converts a tag name string (which may be in upper or mixed case) to a
+ * tag enum.
  */
-GumboTag gumbo_tag_enum(const char* tagname);
-GumboTag gumbo_tagn_enum(const char* tagname, unsigned int length);
+GumboTag gumbo_tagn_enum(const char* tagname, size_t length);
 
 /**
  * Attribute namespaces.
- * HTML includes special handling for XLink, XML, and XMLNS namespaces on
- * attributes.  Everything else goes in the generic "NONE" namespace.
+ * HTML includes special handling for XLink, XML, and XMLNS namespaces
+ * on attributes. Everything else goes in the generic "NONE" namespace.
  */
 typedef enum {
   GUMBO_ATTR_NAMESPACE_NONE,
@@ -217,46 +351,47 @@ typedef enum {
 } GumboAttributeNamespaceEnum;
 
 /**
- * A struct representing a single attribute on an HTML tag.  This is a
- * name-value pair, but also includes information about source locations and
- * original source text.
+ * A struct representing a single attribute on a HTML tag. This is a
+ * name-value pair, but also includes information about source locations
+ * and original source text.
  */
 typedef struct {
   /**
-   * The namespace for the attribute.  This will usually be
-   * GUMBO_ATTR_NAMESPACE_NONE, but some XLink/XMLNS/XML attributes take special
-   * values, per:
-   * http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adjust-foreign-attributes
+   * The namespace for the attribute. This will usually be
+   * `GUMBO_ATTR_NAMESPACE_NONE`, but some XLink/XMLNS/XML attributes
+   * take special values, per:
+   * https://html.spec.whatwg.org/multipage/parsing.html#adjust-foreign-attributes
    */
   GumboAttributeNamespaceEnum attr_namespace;
 
   /**
-   * The name of the attribute.  This is in a freshly-allocated buffer to deal
-   * with case-normalization, and is null-terminated.
+   * The name of the attribute. This is in a freshly-allocated buffer to
+   * deal with case-normalization and is null-terminated.
    */
   const char* name;
 
   /**
-   * The original text of the attribute name, as a pointer into the original
-   * source buffer.
+   * The original text of the attribute name, as a pointer into the
+   * original source buffer.
    */
   GumboStringPiece original_name;
 
   /**
-   * The value of the attribute.  This is in a freshly-allocated buffer to deal
-   * with unescaping, and is null-terminated.  It does not include any quotes
-   * that surround the attribute.  If the attribute has no value (for example,
-   * 'selected' on a checkbox), this will be an empty string.
+   * The value of the attribute. This is in a freshly-allocated buffer
+   * to deal with unescaping and is null-terminated. It does not include
+   * any quotes that surround the attribute. If the attribute has no
+   * value (for example, `selected` on a checkbox) this will be an empty
+   * string.
    */
   const char* value;
 
   /**
-   * The original text of the value of the attribute.  This points into the
-   * original source buffer.  It includes any quotes that surround the
-   * attribute, and you can look at original_value.data[0] and
-   * original_value.data[original_value.length - 1] to determine what the quote
-   * characters were.  If the attribute has no value, this will be a 0-length
-   * string.
+   * The original text of the value of the attribute. This points into
+   * the original source buffer. It includes any quotes that surround
+   * the attribute and you can look at `original_value.data[0]` and
+   * `original_value.data[original_value.length - 1]` to determine what
+   * the quote characters were. If the attribute has no value this will
+   * be a 0-length string.
    */
   GumboStringPiece original_value;
 
@@ -264,9 +399,9 @@ typedef struct {
   GumboSourcePosition name_start;
 
   /**
-   * The ending position of the attribute name.  This is not always derivable
+   * The ending position of the attribute name. This is not always derivable
    * from the starting position of the value because of the possibility of
-   * whitespace around the = sign.
+   * whitespace around the `=` sign.
    */
   GumboSourcePosition name_end;
 
@@ -278,34 +413,37 @@ typedef struct {
 } GumboAttribute;
 
 /**
- * Given a vector of GumboAttributes, look up the one with the specified name
- * and return it, or NULL if no such attribute exists.  This uses a
- * case-insensitive match, as HTML is case-insensitive.
+ * Given a vector of `GumboAttribute`s, look up the one with the
+ * specified name and return it, or `NULL` if no such attribute exists.
+ * This uses a case-insensitive match, as HTML is case-insensitive.
  */
 GumboAttribute* gumbo_get_attribute(const GumboVector* attrs, const char* name);
 
 /**
- * Enum denoting the type of node.  This determines the type of the node.v
- * union.
+ * Enum denoting the type of node. This determines the type of the
+ * `node.v` union.
  */
 typedef enum {
-  /** Document node.  v will be a GumboDocument. */
+  /** Document node. `v` will be a `GumboDocument`. */
   GUMBO_NODE_DOCUMENT,
-  /** Element node.  v will be a GumboElement. */
+  /** Element node. `v` will be a `GumboElement`. */
   GUMBO_NODE_ELEMENT,
-  /** Text node.  v will be a GumboText. */
+  /** Text node. `v` will be a `GumboText`. */
   GUMBO_NODE_TEXT,
-  /** CDATA node. v will be a GumboText. */
+  /** CDATA node. `v` will be a `GumboText`. */
   GUMBO_NODE_CDATA,
-  /** Comment node.  v will be a GumboText, excluding comment delimiters. */
+  /** Comment node. `v` will be a `GumboText`, excluding comment delimiters. */
   GUMBO_NODE_COMMENT,
-  /** Text node, where all contents is whitespace.  v will be a GumboText. */
+  /** Text node, where all contents is whitespace. `v` will be a `GumboText`. */
   GUMBO_NODE_WHITESPACE,
-  /** Template node.  This is separate from GUMBO_NODE_ELEMENT because many
-   * client libraries will want to ignore the contents of template nodes, as
-   * the spec suggests.  Recursing on GUMBO_NODE_ELEMENT will do the right thing
-   * here, while clients that want to include template contents should also
-   * check for GUMBO_NODE_TEMPLATE.  v will be a GumboElement.  */
+  /**
+   * Template node. This is separate from `GUMBO_NODE_ELEMENT` because
+   * many client libraries will want to ignore the contents of template
+   * nodes, as the spec suggests. Recursing on `GUMBO_NODE_ELEMENT` will
+   * do the right thing here, while clients that want to include template
+   * contents should also check for `GUMBO_NODE_TEMPLATE`. `v` will be a
+   * `GumboElement`.
+   */
   GUMBO_NODE_TEMPLATE
 } GumboNodeType;
 
@@ -315,9 +453,7 @@ typedef enum {
  */
 typedef struct GumboInternalNode GumboNode;
 
-/**
- * http://www.whatwg.org/specs/web-apps/current-work/complete/dom.html#quirks-mode
- */
+/** https://dom.spec.whatwg.org/#concept-document-quirks */
 typedef enum {
   GUMBO_DOCTYPE_NO_QUIRKS,
   GUMBO_DOCTYPE_QUIRKS,
@@ -326,10 +462,11 @@ typedef enum {
 
 /**
  * Namespaces.
- * Unlike in X(HT)ML, namespaces in HTML5 are not denoted by a prefix.  Rather,
- * anything inside an <svg> tag is in the SVG namespace, anything inside the
- * <math> tag is in the MathML namespace, and anything else is inside the HTML
- * namespace.  No other namespaces are supported, so this can be an enum only.
+ * Unlike in X(HT)ML, namespaces in HTML5 are not denoted by a prefix.
+ * Rather, anything inside an `<svg>` tag is in the SVG namespace,
+ * anything inside the `<math>` tag is in the MathML namespace, and
+ * anything else is inside the HTML namespace. No other namespaces are
+ * supported, so this can be an `enum`.
  */
 typedef enum {
   GUMBO_NAMESPACE_HTML,
@@ -339,66 +476,70 @@ typedef enum {
 
 /**
  * Parse flags.
- * We track the reasons for parser insertion of nodes and store them in a
- * bitvector in the node itself.  This lets client code optimize out nodes that
- * are implied by the HTML structure of the document, or flag constructs that
- * may not be allowed by a style guide, or track the prevalence of incorrect or
- * tricky HTML code.
+ * We track the reasons for parser insertion of nodes and store them in
+ * a bitvector in the node itself. This lets client code optimize out
+ * nodes that are implied by the HTML structure of the document, or flag
+ * constructs that may not be allowed by a style guide, or track the
+ * prevalence of incorrect or tricky HTML code.
  */
 typedef enum {
   /**
-   * A normal node - both start and end tags appear in the source, nothing has
-   * been reparented.
+   * A normal node -- both start and end tags appear in the source,
+   * nothing has been reparented.
    */
   GUMBO_INSERTION_NORMAL = 0,
 
   /**
-   * A node inserted by the parser to fulfill some implicit insertion rule.
-   * This is usually set in addition to some other flag giving a more specific
-   * insertion reason; it's a generic catch-all term meaning "The start tag for
-   * this node did not appear in the document source".
+   * A node inserted by the parser to fulfill some implicit insertion
+   * rule. This is usually set in addition to some other flag giving a
+   * more specific insertion reason; it's a generic catch-all term
+   * meaning "The start tag for this node did not appear in the document
+   * source".
    */
   GUMBO_INSERTION_BY_PARSER = 1 << 0,
 
   /**
-   * A flag indicating that the end tag for this node did not appear in the
-   * document source.  Note that in some cases, you can still have
-   * parser-inserted nodes with an explicit end tag: for example, "Text</html>"
-   * has GUMBO_INSERTED_BY_PARSER set on the <html> node, but
-   * GUMBO_INSERTED_END_TAG_IMPLICITLY is unset, as the </html> tag actually
-   * exists.  This flag will be set only if the end tag is completely missing;
-   * in some cases, the end tag may be misplaced (eg. a </body> tag with text
-   * afterwards), which will leave this flag unset and require clients to
-   * inspect the parse errors for that case.
+   * A flag indicating that the end tag for this node did not appear in
+   * the document source. Note that in some cases, you can still have
+   * parser-inserted nodes with an explicit end tag. For example,
+   * `Text</html>` has `GUMBO_INSERTED_BY_PARSER` set on the `<html>`
+   * node, but `GUMBO_INSERTED_END_TAG_IMPLICITLY` is unset, as the
+   * `</html>` tag actually exists.
+   *
+   * This flag will be set only if the end tag is completely missing.
+   * In some cases, the end tag may be misplaced (e.g. a `</body>` tag
+   * with text afterwards), which will leave this flag unset and require
+   * clients to inspect the parse errors for that case.
    */
   GUMBO_INSERTION_IMPLICIT_END_TAG = 1 << 1,
 
   // Value 1 << 2 was for a flag that has since been removed.
 
   /**
-   * A flag for nodes that are inserted because their presence is implied by
-   * other tags, eg. <html>, <head>, <body>, <tbody>, etc.
+   * A flag for nodes that are inserted because their presence is
+   * implied by other tags, e.g. `<html>`, `<head>`, `<body>`,
+   * `<tbody>`, etc.
    */
   GUMBO_INSERTION_IMPLIED = 1 << 3,
 
   /**
-   * A flag for nodes that are converted from their end tag equivalents.  For
-   * example, </p> when no paragraph is open implies that the parser should
-   * create a <p> tag and immediately close it, while </br> means the same thing
-   * as <br>.
+   * A flag for nodes that are converted from their end tag equivalents.
+   * For example, `</p>` when no paragraph is open implies that the
+   * parser should create a `<p>` tag and immediately close it, while
+   * `</br>` means the same thing as `<br>`.
    */
   GUMBO_INSERTION_CONVERTED_FROM_END_TAG = 1 << 4,
 
-  /** A flag for nodes that are converted from the parse of an <isindex> tag. */
-  GUMBO_INSERTION_FROM_ISINDEX = 1 << 5,
+  // Value 1 << 5 was for a flag that has since been removed.
 
-  /** A flag for <image> tags that are rewritten as <img>. */
+  /** A flag for `<image>` tags that are rewritten as `<img>`. */
   GUMBO_INSERTION_FROM_IMAGE = 1 << 6,
 
   /**
-   * A flag for nodes that are cloned as a result of the reconstruction of
-   * active formatting elements.  This is set only on the clone; the initial
-   * portion of the formatting run is a NORMAL node with an IMPLICIT_END_TAG.
+   * A flag for nodes that are cloned as a result of the reconstruction
+   * of active formatting elements. This is set only on the clone; the
+   * initial portion of the formatting run is a NORMAL node with an
+   * `IMPLICIT_END_TAG`.
    */
   GUMBO_INSERTION_RECONSTRUCTED_FORMATTING_ELEMENT = 1 << 7,
 
@@ -415,18 +556,19 @@ typedef enum {
   GUMBO_INSERTION_FOSTER_PARENTED = 1 << 10,
 } GumboParseFlags;
 
-/**
- * Information specific to document nodes.
- */
+/** Information specific to document nodes. */
 typedef struct {
   /**
-   * An array of GumboNodes, containing the children of this element.  This will
-   * normally consist of the <html> element and any comment nodes found.
-   * Pointers are owned.
+   * An array of `GumboNode`s, containing the children of this element.
+   * This will normally consist of the `<html>` element and any comment
+   * nodes found. Pointers are owned.
    */
   GumboVector /* GumboNode* */ children;
 
-  // True if there was an explicit doctype token as opposed to it being omitted.
+  /**
+   * `true` if there was an explicit doctype token, as opposed to it
+   * being omitted.
+   */
   bool has_doctype;
 
   // Fields from the doctype token, copied verbatim.
@@ -435,65 +577,70 @@ typedef struct {
   const char* system_identifier;
 
   /**
-   * Whether or not the document is in QuirksMode, as determined by the values
-   * in the GumboTokenDocType template.
+   * Whether or not the document is in QuirksMode, as determined by the
+   * values in the GumboTokenDocType template.
    */
   GumboQuirksModeEnum doc_type_quirks_mode;
 } GumboDocument;
 
 /**
- * The struct used to represent TEXT, CDATA, COMMENT, and WHITESPACE elements.
- * This contains just a block of text and its position.
+ * The struct used to represent TEXT, CDATA, COMMENT, and WHITESPACE
+ * elements. This contains just a block of text and its position.
  */
 typedef struct {
   /**
-   * The text of this node, after entities have been parsed and decoded.  For
-   * comment/cdata nodes, this does not include the comment delimiters.
+   * The text of this node, after entities have been parsed and decoded.
+   * For comment and cdata nodes, this does not include the comment
+   * delimiters.
    */
   const char* text;
 
   /**
-   * The original text of this node, as a pointer into the original buffer.  For
-   * comment/cdata nodes, this includes the comment delimiters.
+   * The original text of this node, as a pointer into the original
+   * buffer. For comment/cdata nodes, this includes the comment
+   * delimiters.
    */
   GumboStringPiece original_text;
 
   /**
-   * The starting position of this node.  This corresponds to the position of
-   * original_text, before entities are decoded.
+   * The starting position of this node. This corresponds to the
+   * position of `original_text`, before entities are decoded.
    * */
   GumboSourcePosition start_pos;
 } GumboText;
 
 /**
- * The struct used to represent all HTML elements.  This contains information
- * about the tag, attributes, and child nodes.
+ * The struct used to represent all HTML elements. This contains
+ * information about the tag, attributes, and child nodes.
  */
 typedef struct {
   /**
-   * An array of GumboNodes, containing the children of this element.  Pointers
-   * are owned.
+   * An array of `GumboNode`s, containing the children of this element.
+   * Pointers are owned.
    */
   GumboVector /* GumboNode* */ children;
 
   /** The GumboTag enum for this element. */
   GumboTag tag;
 
+  /** The name for this element. */
+  const char* name;
+
   /** The GumboNamespaceEnum for this element. */
   GumboNamespaceEnum tag_namespace;
 
   /**
-   * A GumboStringPiece pointing to the original tag text for this element,
-   * pointing directly into the source buffer.  If the tag was inserted
-   * algorithmically (for example, <head> or <tbody> insertion), this will be a
-   * zero-length string.
+   * A `GumboStringPiece` pointing to the original tag text for this
+   * element, pointing directly into the source buffer. If the tag was
+   * inserted algorithmically (for example, `<head>` or `<tbody>`
+   * insertion), this will be a zero-length string.
    */
   GumboStringPiece original_tag;
 
   /**
-   * A GumboStringPiece pointing to the original end tag text for this element.
-   * If the end tag was inserted algorithmically, (for example, closing a
-   * self-closing tag), this will be a zero-length string.
+   * A `GumboStringPiece` pointing to the original end tag text for this
+   * element. If the end tag was inserted algorithmically, (for example,
+   * closing a self-closing tag), this will be a zero-length string.
    */
   GumboStringPiece original_end_tag;
 
@@ -504,30 +651,31 @@ typedef struct {
   GumboSourcePosition end_pos;
 
   /**
-   * An array of GumboAttributes, containing the attributes for this tag in the
-   * order that they were parsed.  Pointers are owned.
+   * An array of `GumboAttribute`s, containing the attributes for this
+   * tag in the order that they were parsed. Pointers are owned.
    */
   GumboVector /* GumboAttribute* */ attributes;
 } GumboElement;
 
 /**
- * A supertype for GumboElement and GumboText, so that we can include one
- * generic type in lists of children and cast as necessary to subtypes.
+ * A supertype for `GumboElement` and `GumboText`, so that we can
+ * include one generic type in lists of children and cast as necessary
+ * to subtypes.
  */
 struct GumboInternalNode {
   /** The type of node that this is. */
   GumboNodeType type;
 
-  /** Pointer back to parent node.  Not owned. */
+  /** Pointer back to parent node. Not owned. */
   GumboNode* parent;
 
   /** The index within the parent's children vector of this node. */
-  size_t index_within_parent;
+  unsigned int index_within_parent;
 
   /**
-   * A bitvector of flags containing information about why this element was
-   * inserted into the parse tree, including a variety of special parse
-   * situations.
+   * A bitvector of flags containing information about why this element
+   * was inserted into the parse tree, including a variety of special
+   * parse situations.
    */
   GumboParseFlags parse_flags;
 
@@ -539,133 +687,257 @@ struct GumboInternalNode {
   } v;
 };
 
-/**
- * The type for an allocator function.  Takes the 'userdata' member of the
- * GumboParser struct as its first argument.  Semantics should be the same as
- * malloc, i.e. return a block of size_t bytes on success or NULL on failure.
- * Allocating a block of 0 bytes behaves as per malloc.
- */
-// TODO(jdtang): Add checks throughout the codebase for out-of-memory condition.
-typedef void* (*GumboAllocatorFunction)(void* userdata, size_t size);
-
-/**
- * The type for a deallocator function.  Takes the 'userdata' member of the
- * GumboParser struct as its first argument.
- */
-typedef void (*GumboDeallocatorFunction)(void* userdata, void* ptr);
-
 /**
  * Input struct containing configuration options for the parser.
- * These let you specify alternate memory managers, provide different error
- * handling, etc.
- * Use kGumboDefaultOptions for sensible defaults, and only set what you need.
+ * These let you specify alternate memory managers, provide different
+ * error handling, etc. Use `kGumboDefaultOptions` for sensible
+ * defaults and only set what you need.
  */
 typedef struct GumboInternalOptions {
-  /** A memory allocator function.  Default: malloc. */
-  GumboAllocatorFunction allocator;
-
-  /** A memory deallocator function. Default: free. */
-  GumboDeallocatorFunction deallocator;
+  /**
+   * The tab-stop size, for computing positions in HTML files that
+   * use tabs. Default: `8`.
+   */
+  int tab_stop;
 
   /**
-   * An opaque object that's passed in as the first argument to all callbacks
-   * used by this library.  Default: NULL.
+   * Whether or not to stop parsing when the first error is encountered.
+   * Default: `false`.
    */
-  void* userdata;
+  bool stop_on_first_error;
 
   /**
-   * The tab-stop size, for computing positions in source code that uses tabs.
-   * Default: 8.
+   * Maximum allowed number of attributes per element. If this limit is
+   * exceeded, the parser will return early with a partial document and
+   * the returned `GumboOutput` will have its `status` field set to
+   * `GUMBO_STATUS_TOO_MANY_ATTRIBUTES`. Set to `-1` to disable the limit.
+   * Default: `400`.
    */
-  int tab_stop;
+  int max_attributes;
 
   /**
-   * Whether or not to stop parsing when the first error is encountered.
-   * Default: false.
+   * Maximum allowed depth for the parse tree. If this limit is exceeded,
+   * the parser will return early with a partial document and the returned
+   * `GumboOutput` will have its `status` field set to
+   * `GUMBO_STATUS_TREE_TOO_DEEP`.
+   * Default: `400`.
    */
-  bool stop_on_first_error;
+  unsigned int max_tree_depth;
 
   /**
-   * The maximum number of errors before the parser stops recording them.  This
-   * is provided so that if the page is totally borked, we don't completely fill
-   * up the errors vector and exhaust memory with useless redundant errors.  Set
-   * to -1 to disable the limit.
-   * Default: -1
+   * The maximum number of errors before the parser stops recording
+   * them. This is provided so that if the page is totally borked, we
+   * don't completely fill up the errors vector and exhaust memory with
+   * useless redundant errors. Set to `-1` to disable the limit.
+   * Default: `-1`.
    */
   int max_errors;
 
   /**
    * The fragment context for parsing:
-   * https://html.spec.whatwg.org/multipage/syntax.html#parsing-html-fragments
+   * https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
    *
-   * If GUMBO_TAG_LAST is passed here, it is assumed to be "no fragment", i.e.
-   * the regular parsing algorithm.  Otherwise, pass the tag enum for the
-   * intended parent of the parsed fragment.  We use just the tag enum rather
-   * than a full node because that's enough to set all the parsing context we
-   * need, and it provides some additional flexibility for client code to act as
-   * if parsing a fragment even when a full HTML tree isn't available.
+   * If `NULL` is passed here, it is assumed to be "no
+   * fragment", i.e. the regular parsing algorithm. Otherwise, pass the
+   * tag name for the intended parent of the parsed fragment. We use the
+   * tag name, namespace, and encoding attribute which are sufficient to
+   * set all of the parsing context needed for fragment parsing.
    *
-   * Default: GUMBO_TAG_LAST
+   * Default: `NULL`.
    */
-  GumboTag fragment_context;
+  const char* fragment_context;
 
   /**
-   * The namespace for the fragment context.  This lets client code
-   * differentiate between, say, parsing a <title> tag in SVG vs. parsing it in
-   * HTML.
-   * Default: GUMBO_NAMESPACE_HTML
+   * The namespace for the fragment context. This lets client code
+   * differentiate between, say, parsing a `<title>` tag in SVG vs.
+   * parsing it in HTML.
+   *
+   * Default: `GUMBO_NAMESPACE_HTML`.
    */
   GumboNamespaceEnum fragment_namespace;
+
+  /**
+   * The value of the fragment context's `encoding` attribute, if any.
+   * Set to `NULL` for no `encoding` attribute.
+   *
+   * Default: `NULL`.
+   */
+  const char* fragment_encoding;
+
+  /**
+   * Quirks mode for fragment parsing. The quirks mode for a given DOCTYPE can
+   * be looked up using `gumbo_compute_quirks_mode()`.
+   *
+   * Default: `GUMBO_DOCTYPE_NO_QUIRKS`.
+   */
+  GumboQuirksModeEnum quirks_mode;
+
+  /**
+   * For fragment parsing. Set this to true if the context node has a form
+   * element as an ancestor.
+   *
+   * Default: `false`.
+   */
+  bool fragment_context_has_form_ancestor;
 } GumboOptions;
 
 /** Default options struct; use this with gumbo_parse_with_options. */
 extern const GumboOptions kGumboDefaultOptions;
 
+/**
+ * Status code indicating whether parsing finished successfully or
+ * was stopped mid-document due to exceptional circumstances.
+ */
+typedef enum {
+  /**
+   * Indicates that parsing completed successfuly. The resulting tree
+   * will be a complete document.
+   */
+  GUMBO_STATUS_OK,
+
+  /**
+   * Indicates that the maximum element nesting limit
+   * (`GumboOptions::max_tree_depth`) was reached during parsing. The
+   * resulting tree will be a partial document, with no further nodes
+   * created after the point where the limit was reached. The partial
+   * document may be useful for constructing an error message but
+   * typically shouldn't be used for other purposes.
+   */
+  GUMBO_STATUS_TREE_TOO_DEEP,
+
+  /**
+   * Indicates that the maximum number of attributes per element
+   * (`GumboOptions::max_attributes`) was reached during parsing. The
+   * resulting tree will be a partial document, with no further nodes
+   * created after the point where the limit was reached. The partial
+   * document may be useful for constructing an error message but
+   * typically shouldn't be used for other purposes.
+   */
+  GUMBO_STATUS_TOO_MANY_ATTRIBUTES,
+
+  // Currently unused
+  GUMBO_STATUS_OUT_OF_MEMORY,
+} GumboOutputStatus;
+
+
 /** The output struct containing the results of the parse. */
 typedef struct GumboInternalOutput {
   /**
-   * Pointer to the document node.  This is a GumboNode of type NODE_DOCUMENT
-   * that contains the entire document as its child.
+   * Pointer to the document node. This is a `GumboNode` of type
+   * `NODE_DOCUMENT` that contains the entire document as its child.
    */
   GumboNode* document;
 
   /**
-   * Pointer to the root node.  This the <html> tag that forms the root of the
-   * document.
+   * Pointer to the root node. This is the `<html>` tag that forms the
+   * root of the document.
    */
   GumboNode* root;
 
   /**
    * A list of errors that occurred during the parse.
-   * NOTE: In version 1.0 of this library, the API for errors hasn't been fully
-   * fleshed out and may change in the future.  For this reason, the GumboError
-   * header isn't part of the public API.  Contact us if you need errors
-   * reported so we can work out something appropriate for your use-case.
    */
   GumboVector /* GumboError */ errors;
+
+  /**
+   * True if the parser encounted an error.
+   *
+   * This can be true and `errors` an empty `GumboVector` if the `max_errors`
+   * option was set to 0.
+   */
+  bool document_error;
+
+  /**
+   * A status code indicating whether parsing finished successfully or was
+   * stopped mid-document due to exceptional circumstances.
+   */
+  GumboOutputStatus status;
 } GumboOutput;
 
 /**
- * Parses a buffer of UTF8 text into an GumboNode parse tree.  The buffer must
- * live at least as long as the parse tree, as some fields (eg. original_text)
- * point directly into the original buffer.
+ * Parses a buffer of UTF-8 text into an `GumboNode` parse tree. The
+ * buffer must live at least as long as the parse tree, as some fields
+ * (eg. `original_text`) point directly into the original buffer.
  *
  * This doesn't support buffers longer than 4 gigabytes.
  */
 GumboOutput* gumbo_parse(const char* buffer);
 
 /**
- * Extended version of gumbo_parse that takes an explicit options structure,
- * buffer, and length.
+ * Extended version of `gumbo_parse` that takes an explicit options
+ * structure, buffer, and length.
+ */
+GumboOutput* gumbo_parse_with_options (
+  const GumboOptions* options,
+  const char* buffer,
+  size_t buffer_length
+);
+
+/**
+ * Compute the quirks mode based on the name, public identifier, and system
+ * identifier. Any of these may be `NULL` to indicate a missing value.
+ */
+GumboQuirksModeEnum gumbo_compute_quirks_mode (
+  const char *name,
+  const char *pubid,
+  const char *sysid
+);
+
+/** Convert a `GumboOutputStatus` code into a readable description. */
+const char* gumbo_status_to_string(GumboOutputStatus status);
+
+/** Release the memory used for the parse tree and parse errors. */
+void gumbo_destroy_output(GumboOutput* output);
+
+/** Opaque GumboError type */
+typedef struct GumboInternalError GumboError;
+
+/**
+ * Returns the position of the error.
  */
-GumboOutput* gumbo_parse_with_options(
-    const GumboOptions* options, const char* buffer, size_t buffer_length);
+GumboSourcePosition gumbo_error_position(const GumboError* error);
 
-/** Release the memory used for the parse tree & parse errors. */
-void gumbo_destroy_output(const GumboOptions* options, GumboOutput* output);
+/**
+ * Returns a constant string representation of the error's code. This is owned
+ * by the library and should not be freed by the caller.
+ */
+const char* gumbo_error_code(const GumboError* error);
+
+/**
+ * Prints an error to a string. This stores a freshly-allocated buffer
+ * containing the error message text in output. The caller is responsible for
+ * freeing the buffer. The size of the error message is returned. The error
+ * message itself may not be NULL-terminated and may contain NULL bytes so the
+ * returned size must be used.
+ */
+size_t gumbo_error_to_string(const GumboError* error, char **output);
+
+/**
+ * Prints a caret diagnostic to a string. This stores a freshly-allocated
+ * buffer containing the error message text in output. The caller is responsible for
+ * freeing the buffer. The size of the error message is returned. The error
+ * message itself may not be NULL-terminated and may contain NULL bytes so the
+ * returned size must be used.
+ */
+size_t gumbo_caret_diagnostic_to_string (
+  const GumboError* error,
+  const char* source_text,
+  size_t source_length,
+  char** output
+);
+
+/**
+ * Like gumbo_caret_diagnostic_to_string, but prints the text to stdout
+ * instead of writing to a string.
+ */
+void gumbo_print_caret_diagnostic (
+  const GumboError* error,
+  const char* source_text,
+  size_t source_length
+);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif  // GUMBO_GUMBO_H_
+#endif // GUMBO_H