nokogumbo 2.0.0.pre.alpha → 2.0.4

data/gumbo-parser/src/char_ref.h

@@ -1,40 +1,25 @@
 #ifndef GUMBO_CHAR_REF_H_
 #define GUMBO_CHAR_REF_H_
 
-#include <stdbool.h>
+#include <stdlib.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct GumboInternalParser;
-struct GumboInternalUtf8Iterator;
-
 // Value that indicates no character was produced.
-extern const int kGumboNoChar;
-
-// Certain named character references generate two codepoints, not one, and so
-// the gumbo_consume_char_ref subroutine needs to return this instead of an int.
-// The first field will be kGumboNoChar if no character reference was found; the
-// second field will be kGumboNoChar if that is the case or if the character
-// reference returns only a single codepoint.
-typedef struct {
-  int first;
-  int second;
-} OneOrTwoCodepoints;
-
-// Implements the "consume a character reference" section of the spec.
-// This reads in characters from the input as necessary, and fills in a
-// OneOrTwoCodepoints struct containing the characters read. It may add parse
-// errors to the GumboParser's errors vector, if the spec calls for it. Pass a
-// space for the "additional allowed char" when the spec says "with no
-// additional allowed char". Returns false on parse error, true otherwise.
-bool gumbo_consume_char_ref (
-  struct GumboInternalParser* parser,
-  struct GumboInternalUtf8Iterator* input,
-  int additional_allowed_char,
-  bool is_in_attribute,
-  OneOrTwoCodepoints* output
+#define kGumboNoChar (-1)
+
+// On input, str points to the start of the string to match and size is the
+// size of the string.
+//
+// Returns the length of the match or 0 if there is no match.
+// output[0] contains the first codepoint and output[1] contains the second if
+// there are two, otherwise output[1] contains kGumboNoChar.
+size_t match_named_char_ref (
+  const char *str,
+  size_t size,
+  int output[2]
 );
 
 #ifdef __cplusplus

data/gumbo-parser/src/error.c

@@ -19,6 +19,7 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
+#include "ascii.h"
 #include "error.h"
 #include "gumbo.h"
 #include "macros.h"
@@ -45,13 +46,13 @@ static int PRINTF(2) print_message (
     args
   );
   va_end(args);
-#ifdef _MSC_VER
+#if _MSC_VER && _MSC_VER < 1900
   if (bytes_written == -1) {
-    // vsnprintf returns -1 on MSVC++ if there's not enough capacity, instead of
-    // returning the number of bytes that would've been written had there been
-    // enough. In this case, we'll double the buffer size and hope it fits when
-    // we retry (letting it fail and returning 0 if it doesn't), since there's
-    // no way to smartly resize the buffer.
+    // vsnprintf returns -1 on older MSVC++ if there's not enough capacity,
+    // instead of returning the number of bytes that would've been written had
+    // there been enough. In this case, we'll double the buffer size and hope
+    // it fits when we retry (letting it fail and returning 0 if it doesn't),
+    // since there's no way to smartly resize the buffer.
     gumbo_string_buffer_reserve(output->capacity * 2, output);
     va_start(args, format);
     int result = vsnprintf (
@@ -101,6 +102,214 @@ static void print_tag_stack (
   gumbo_string_buffer_append_codepoint('.', output);
 }
 
+static void handle_tokenizer_error (
+  const GumboError* error,
+  GumboStringBuffer* output
+) {
+  switch (error->type) {
+  case GUMBO_ERR_ABRUPT_CLOSING_OF_EMPTY_COMMENT:
+      print_message(output, "Empty comment abruptly closed by '%s', use '-->'.",
+                    error->v.tokenizer.state == GUMBO_LEX_COMMENT_START? ">" : "->");
+    break;
+  case GUMBO_ERR_ABRUPT_DOCTYPE_PUBLIC_IDENTIFIER:
+    print_message (
+      output,
+      "DOCTYPE public identifier missing closing %s.",
+      error->v.tokenizer.state == GUMBO_LEX_DOCTYPE_PUBLIC_ID_DOUBLE_QUOTED?
+        "quotation mark (\")" : "apostrophe (')"
+    );
+    break;
+  case GUMBO_ERR_ABRUPT_DOCTYPE_SYSTEM_IDENTIFIER:
+    print_message (
+      output,
+      "DOCTYPE system identifier missing closing %s.",
+      error->v.tokenizer.state == GUMBO_LEX_DOCTYPE_SYSTEM_ID_DOUBLE_QUOTED?
+        "quotation mark (\")" : "apostrophe (')"
+    );
+    break;
+  case GUMBO_ERR_ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE:
+    print_message (
+      output,
+      "Numeric character reference '%.*s' does not contain any %sdigits.",
+      (int)error->original_text.length, error->original_text.data,
+      error->v.tokenizer.state == GUMBO_LEX_HEXADECIMAL_CHARACTER_REFERENCE_START? "hexadecimal " : ""
+    );
+    break;
+  case GUMBO_ERR_CDATA_IN_HTML_CONTENT:
+    print_message(output, "CDATA section outside foreign (SVG or MathML) content.");
+    break;
+  case GUMBO_ERR_CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE:
+    print_message (
+      output,
+      "Numeric character reference '%.*s' references a code point that is outside the valid Unicode range.",
+      (int)error->original_text.length, error->original_text.data
+    );
+    break;
+  case GUMBO_ERR_CONTROL_CHARACTER_IN_INPUT_STREAM:
+    print_message (
+      output,
+      "Input contains prohibited control code point U+%04X.",
+      error->v.tokenizer.codepoint
+    );
+    break;
+  case GUMBO_ERR_CONTROL_CHARACTER_REFERENCE:
+    print_message (
+      output,
+      "Numeric character reference '%.*s' references prohibited control code point U+%04X.",
+      (int)error->original_text.length, error->original_text.data,
+      error->v.tokenizer.codepoint
+    );
+    break;
+  case GUMBO_ERR_END_TAG_WITH_ATTRIBUTES:
+    print_message(output, "End tag contains attributes.");
+    break;
+  case GUMBO_ERR_DUPLICATE_ATTRIBUTE:
+    print_message(output, "Tag contains multiple attributes with the same name.");
+    break;
+  case GUMBO_ERR_END_TAG_WITH_TRAILING_SOLIDUS:
+    print_message(output, "End tag ends with '/>', use '>'.");
+    break;
+  case GUMBO_ERR_EOF_BEFORE_TAG_NAME:
+    print_message(output, "End of input where a tag name is expected.");
+    break;
+  case GUMBO_ERR_EOF_IN_CDATA:
+    print_message(output, "End of input in CDATA section.");
+    break;
+  case GUMBO_ERR_EOF_IN_COMMENT:
+    print_message(output, "End of input in comment.");
+    break;
+  case GUMBO_ERR_EOF_IN_DOCTYPE:
+    print_message(output, "End of input in DOCTYPE.");
+    break;
+  case GUMBO_ERR_EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT:
+    print_message(output, "End of input in text that resembles an HTML comment inside script element content.");
+    break;
+  case GUMBO_ERR_EOF_IN_TAG:
+    print_message(output, "End of input in tag.");
+    break;
+  case GUMBO_ERR_INCORRECTLY_CLOSED_COMMENT:
+    print_message(output, "Comment closed incorrectly by '--!>', use '-->'.");
+    break;
+  case GUMBO_ERR_INCORRECTLY_OPENED_COMMENT:
+    print_message(output, "Comment, DOCTYPE, or CDATA opened incorrectly, use '<!--', '<!DOCTYPE', or '<![CDATA['.");
+    break;
+  case GUMBO_ERR_INVALID_CHARACTER_SEQUENCE_AFTER_DOCTYPE_NAME:
+    print_message(output, "Invalid character sequence after DOCTYPE name, expected 'PUBLIC', 'SYSTEM', or '>'.");
+    break;
+  case GUMBO_ERR_INVALID_FIRST_CHARACTER_OF_TAG_NAME:
+    if (gumbo_ascii_isascii(error->v.tokenizer.codepoint)
+        && !gumbo_ascii_iscntrl(error->v.tokenizer.codepoint))
+      print_message(output, "Invalid first character of tag name '%c'.", error->v.tokenizer.codepoint);
+    else
+      print_message(output, "Invalid first code point of tag name U+%04X.", error->v.tokenizer.codepoint);
+    break;
+  case GUMBO_ERR_MISSING_ATTRIBUTE_VALUE:
+    print_message(output, "Missing attribute value.");
+    break;
+  case GUMBO_ERR_MISSING_DOCTYPE_NAME:
+    print_message(output, "Missing DOCTYPE name.");
+    break;
+  case GUMBO_ERR_MISSING_DOCTYPE_PUBLIC_IDENTIFIER:
+    print_message(output, "Missing DOCTYPE public identifier.");
+    break;
+  case GUMBO_ERR_MISSING_DOCTYPE_SYSTEM_IDENTIFIER:
+    print_message(output, "Missing DOCTYPE system identifier.");
+    break;
+  case GUMBO_ERR_MISSING_END_TAG_NAME:
+    print_message(output, "Missing end tag name.");
+    break;
+  case GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER:
+    print_message(output, "Missing quote before DOCTYPE public identifier.");
+    break;
+  case GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:
+    print_message(output, "Missing quote before DOCTYPE system identifier.");
+    break;
+  case GUMBO_ERR_MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE:
+    print_message(output, "Missing semicolon after character reference '%.*s'.",
+                  (int)error->original_text.length, error->original_text.data);
+    break;
+  case GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_PUBLIC_KEYWORD:
+    print_message(output, "Missing whitespace after 'PUBLIC' keyword.");
+    break;
+  case GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_SYSTEM_KEYWORD:
+    print_message(output, "Missing whitespace after 'SYSTEM' keyword.");
+    break;
+  case GUMBO_ERR_MISSING_WHITESPACE_BEFORE_DOCTYPE_NAME:
+    print_message(output, "Missing whitespace between 'DOCTYPE' keyword and DOCTYPE name.");
+    break;
+  case GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_ATTRIBUTES:
+    print_message(output, "Missing whitespace between attributes.");
+    break;
+  case GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS:
+    print_message(output, "Missing whitespace between DOCTYPE public and system identifiers.");
+    break;
+  case GUMBO_ERR_NESTED_COMMENT:
+    print_message(output, "Nested comment.");
+    break;
+  case GUMBO_ERR_NONCHARACTER_CHARACTER_REFERENCE:
+    print_message (
+      output,
+      "Numeric character reference '%.*s' references noncharacter U+%04X.",
+      (int)error->original_text.length, error->original_text.data,
+      error->v.tokenizer.codepoint
+    );
+    break;
+  case GUMBO_ERR_NONCHARACTER_IN_INPUT_STREAM:
+    print_message(output, "Input contains noncharacter U+%04X.", error->v.tokenizer.codepoint);
+    break;
+  case GUMBO_ERR_NON_VOID_HTML_ELEMENT_START_TAG_WITH_TRAILING_SOLIDUS:
+    print_message(output, "Start tag of nonvoid HTML element ends with '/>', use '>'.");
+    break;
+  case GUMBO_ERR_NULL_CHARACTER_REFERENCE:
+    print_message(output, "Numeric character reference '%.*s' references U+0000.",
+                  (int)error->original_text.length, error->original_text.data);
+    break;
+  case GUMBO_ERR_SURROGATE_CHARACTER_REFERENCE:
+    print_message (
+      output,
+      "Numeric character reference '%.*s' references surrogate U+%4X.",
+      (int)error->original_text.length, error->original_text.data,
+      error->v.tokenizer.codepoint
+    );
+    break;
+  case GUMBO_ERR_SURROGATE_IN_INPUT_STREAM:
+    print_message(output, "Input contains surrogate U+%04X.", error->v.tokenizer.codepoint);
+    break;
+  case GUMBO_ERR_UNEXPECTED_CHARACTER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER:
+    print_message(output, "Unexpected character after DOCTYPE system identifier.");
+    break;
+  case GUMBO_ERR_UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME:
+    print_message(output, "Unexpected character (%c) in attribute name.", error->v.tokenizer.codepoint);
+    break;
+  case GUMBO_ERR_UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE:
+    print_message(output, "Unexpected character (%c) in unquoted attribute value.", error->v.tokenizer.codepoint);
+    break;
+  case GUMBO_ERR_UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME:
+    print_message(output, "Unexpected '=' before an attribute name.");
+    break;
+  case GUMBO_ERR_UNEXPECTED_NULL_CHARACTER:
+    print_message(output, "Input contains unexpected U+0000.");
+    break;
+  case GUMBO_ERR_UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME:
+    print_message(output, "Unexpected '?' where start tag name is expected.");
+    break;
+  case GUMBO_ERR_UNEXPECTED_SOLIDUS_IN_TAG:
+    print_message(output, "Unexpected '/' in tag.");
+    break;
+  case GUMBO_ERR_UNKNOWN_NAMED_CHARACTER_REFERENCE:
+    print_message(output, "Unknown named character reference '%.*s'.",
+                  (int)error->original_text.length, error->original_text.data);
+    break;
+  case GUMBO_ERR_UTF8_INVALID:
+    print_message(output, "Invalid UTF8 encoding.");
+    break;
+  case GUMBO_ERR_UTF8_TRUNCATED:
+    print_message(output, "UTF8 character truncated.");
+    break;
+  case GUMBO_ERR_PARSER:
+    assert(0 && "Unreachable.");
+  }
+}
 static void handle_parser_error (
   const GumboParserError* error,
   GumboStringBuffer* output
@@ -111,7 +320,7 @@ static void handle_parser_error (
   ) {
     print_message (
       output,
-      "The doctype must be the first token in the document"
+      "Expected a doctype token"
     );
     return;
   }
@@ -156,11 +365,14 @@ static void handle_parser_error (
 // pointer to the beginning of the string if this is the first line.
 static const char* find_prev_newline (
   const char* source_text,
+  size_t source_length,
   const char* error_location
 ) {
+  const char* source_end = source_text + source_length;
   assert(error_location >= source_text);
+  assert(error_location <= source_end);
   const char* c = error_location;
-  if (*c == '\n' && c != source_text)
+  if (c != source_text && (error_location == source_end || *c == '\n'))
     --c;
   while (c != source_text && *c != '\n')
     --c;
@@ -168,20 +380,25 @@ static const char* find_prev_newline (
 }
 
 // Finds the next newline in the original source buffer from a given byte
-// location. Returns a character pointer to that newline, or a pointer to the
-// terminating null byte if this is the last line.
+// location. Returns a character pointer to that newline, or a pointer to
+// source_text + source_length if this is the last line.
 static const char* find_next_newline(
-  const char* source_text_end,
+  const char* source_text,
+  size_t source_length,
   const char* error_location
 ) {
-  assert(error_location <= source_text_end);
+  const char* source_end = source_text + source_length;
+  assert(error_location >= source_text);
+  assert(error_location <= source_end);
   const char* c = error_location;
-  while (c != source_text_end && *c != '\n')
+  while (c != source_end && *c != '\n')
     ++c;
   return c;
 }
 
 GumboError* gumbo_add_error(GumboParser* parser) {
+  parser->_output->document_error = true;
+
   int max_errors = parser->_options->max_errors;
   if (max_errors >= 0 && parser->_output->errors.length >= (unsigned int) max_errors) {
     return NULL;
@@ -191,122 +408,156 @@ GumboError* gumbo_add_error(GumboParser* parser) {
   return error;
 }
 
-void gumbo_error_to_string (
+GumboSourcePosition gumbo_error_position(const GumboError* error) {
+  return error->position;
+}
+
+const char* gumbo_error_code(const GumboError* error) {
+  switch (error->type) {
+  // Defined tokenizer errors.
+  case GUMBO_ERR_ABRUPT_CLOSING_OF_EMPTY_COMMENT:
+    return "abrupt-closing-of-empty-comment";
+  case GUMBO_ERR_ABRUPT_DOCTYPE_PUBLIC_IDENTIFIER:
+    return "abrupt-doctype-public-identifier";
+  case GUMBO_ERR_ABRUPT_DOCTYPE_SYSTEM_IDENTIFIER:
+    return "abrupt-doctype-system-identifier";
+  case GUMBO_ERR_ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE:
+    return "absence-of-digits-in-numeric-character-reference";
+  case GUMBO_ERR_CDATA_IN_HTML_CONTENT:
+    return "cdata-in-html-content";
+  case GUMBO_ERR_CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE:
+    return "character-reference-outside-unicode-range";
+  case GUMBO_ERR_CONTROL_CHARACTER_IN_INPUT_STREAM:
+    return "control-character-in-input-stream";
+  case GUMBO_ERR_CONTROL_CHARACTER_REFERENCE:
+    return "control-character-reference";
+  case GUMBO_ERR_END_TAG_WITH_ATTRIBUTES:
+    return "end-tag-with-attributes";
+  case GUMBO_ERR_DUPLICATE_ATTRIBUTE:
+    return "duplicate-attribute";
+  case GUMBO_ERR_END_TAG_WITH_TRAILING_SOLIDUS:
+    return "end-tag-with-trailing-solidus";
+  case GUMBO_ERR_EOF_BEFORE_TAG_NAME:
+    return "eof-before-tag-name";
+  case GUMBO_ERR_EOF_IN_CDATA:
+    return "eof-in-cdata";
+  case GUMBO_ERR_EOF_IN_COMMENT:
+    return "eof-in-comment";
+  case GUMBO_ERR_EOF_IN_DOCTYPE:
+    return "eof-in-doctype";
+  case GUMBO_ERR_EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT:
+    return "eof-in-script-html-comment-like-text";
+  case GUMBO_ERR_EOF_IN_TAG:
+    return "eof-in-tag";
+  case GUMBO_ERR_INCORRECTLY_CLOSED_COMMENT:
+    return "incorrectly-closed-comment";
+  case GUMBO_ERR_INCORRECTLY_OPENED_COMMENT:
+    return "incorrectly-opened-comment";
+  case GUMBO_ERR_INVALID_CHARACTER_SEQUENCE_AFTER_DOCTYPE_NAME:
+    return "invalid-character-sequence-after-doctype-name";
+  case GUMBO_ERR_INVALID_FIRST_CHARACTER_OF_TAG_NAME:
+    return "invalid-first-character-of-tag-name";
+  case GUMBO_ERR_MISSING_ATTRIBUTE_VALUE:
+    return "missing-attribute-value";
+  case GUMBO_ERR_MISSING_DOCTYPE_NAME:
+    return "missing-doctype-name";
+  case GUMBO_ERR_MISSING_DOCTYPE_PUBLIC_IDENTIFIER:
+    return "missing-doctype-public-identifier";
+  case GUMBO_ERR_MISSING_DOCTYPE_SYSTEM_IDENTIFIER:
+    return "missing-doctype-system-identifier";
+  case GUMBO_ERR_MISSING_END_TAG_NAME:
+    return "missing-end-tag-name";
+  case GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER:
+    return "missing-quote-before-doctype-public-identifier";
+  case GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:
+    return "missing-quote-before-doctype-system-identifier";
+  case GUMBO_ERR_MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE:
+    return "missing-semicolon-after-character-reference";
+  case GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_PUBLIC_KEYWORD:
+    return "missing-whitespace-after-doctype-public-keyword";
+  case GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_SYSTEM_KEYWORD:
+    return "missing-whitespace-after-doctype-system-keyword";
+  case GUMBO_ERR_MISSING_WHITESPACE_BEFORE_DOCTYPE_NAME:
+    return "missing-whitespace-before-doctype-name";
+  case GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_ATTRIBUTES:
+    return "missing-whitespace-between-attributes";
+  case GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS:
+    return "missing-whitespace-between-doctype-public-and-system-identifiers";
+  case GUMBO_ERR_NESTED_COMMENT:
+    return "nested-comment";
+  case GUMBO_ERR_NONCHARACTER_CHARACTER_REFERENCE:
+    return "noncharacter-character-reference";
+  case GUMBO_ERR_NONCHARACTER_IN_INPUT_STREAM:
+    return "noncharacter-in-input-stream";
+  case GUMBO_ERR_NON_VOID_HTML_ELEMENT_START_TAG_WITH_TRAILING_SOLIDUS:
+    return "non-void-html-element-start-tag-with-trailing-solidus";
+  case GUMBO_ERR_NULL_CHARACTER_REFERENCE:
+    return "null-character-reference";
+  case GUMBO_ERR_SURROGATE_CHARACTER_REFERENCE:
+    return "surrogate-character-reference";
+  case GUMBO_ERR_SURROGATE_IN_INPUT_STREAM:
+    return "surrogate-in-input-stream";
+  case GUMBO_ERR_UNEXPECTED_CHARACTER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER:
+    return "unexpected-character-after-doctype-system-identifier";
+  case GUMBO_ERR_UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME:
+    return "unexpected-character-in-attribute-name";
+  case GUMBO_ERR_UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE:
+    return "unexpected-character-in-unquoted-attribute-value";
+  case GUMBO_ERR_UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME:
+    return "unexpected-equals-sign-before-attribute-name";
+  case GUMBO_ERR_UNEXPECTED_NULL_CHARACTER:
+    return "unexpected-null-character";
+  case GUMBO_ERR_UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME:
+    return "unexpected-question-mark-instead-of-tag-name";
+  case GUMBO_ERR_UNEXPECTED_SOLIDUS_IN_TAG:
+    return "unexpected-solidus-in-tag";
+  case GUMBO_ERR_UNKNOWN_NAMED_CHARACTER_REFERENCE:
+    return "unknown-named-character-reference";
+
+  // Encoding errors.
+  case GUMBO_ERR_UTF8_INVALID:
+    return "utf8-invalid";
+  case GUMBO_ERR_UTF8_TRUNCATED:
+    return "utf8-truncated";
+
+  // Generic parser error.
+  case GUMBO_ERR_PARSER:
+    return "generic-parser";
+  }
+  // Silence warning about control reaching end of non-void function.
+  // All errors _should_ be handled in the switch statement.
+  return "generic-parser";
+}
+
+static void error_to_string (
   const GumboError* error,
   GumboStringBuffer* output
 ) {
-  print_message (
-    output,
-    "@%zu:%zu: ",
-    error->position.line,
-    error->position.column
-  );
-  switch (error->type) {
-    case GUMBO_ERR_UTF8_INVALID:
-      print_message (
-        output,
-        "Invalid UTF8 character 0x%" PRIx32,
-        error->v.codepoint
-      );
-      break;
-    case GUMBO_ERR_UTF8_TRUNCATED:
-      print_message (
-        output,
-        "Input stream ends with a truncated UTF8 character 0x%" PRIx32,
-        error->v.codepoint
-      );
-      break;
-    case GUMBO_ERR_UTF8_NULL:
-      print_message (
-        output,
-        "Unexpected NULL character in the input stream"
-      );
-      break;
-    case GUMBO_ERR_NUMERIC_CHAR_REF_NO_DIGITS:
-      print_message (
-        output,
-        "No digits after &# in numeric character reference"
-      );
-      break;
-    case GUMBO_ERR_NUMERIC_CHAR_REF_WITHOUT_SEMICOLON:
-      print_message (
-        output,
-        "The numeric character reference &#%" PRIu32 " should be followed "
-        "by a semicolon",
-        error->v.codepoint
-      );
-      break;
-    case GUMBO_ERR_NUMERIC_CHAR_REF_INVALID:
-      print_message (
-        output,
-        "The numeric character reference &#%" PRIu32 "; encodes an invalid "
-        "unicode codepoint",
-        error->v.codepoint
-      );
-      break;
-    case GUMBO_ERR_NAMED_CHAR_REF_WITHOUT_SEMICOLON:
-      // The textual data came from one of the literal strings in the table, and
-      // so it'll be null-terminated.
-      print_message (
-        output,
-        "The named character reference &%.*s should be followed by a "
-        "semicolon",
-        (int) error->v.text.length,
-        error->v.text.data
-      );
-      break;
-    case GUMBO_ERR_NAMED_CHAR_REF_INVALID:
-      print_message (
-        output,
-        "The named character reference &%.*s; is not a valid entity name",
-        (int) error->v.text.length,
-        error->v.text.data
-      );
-      break;
-    case GUMBO_ERR_DUPLICATE_ATTR:
-      print_message (
-        output,
-        "Attribute %s occurs multiple times, at positions %u and %u",
-        error->v.duplicate_attr.name,
-        error->v.duplicate_attr.original_index,
-        error->v.duplicate_attr.new_index
-      );
-      break;
-    case GUMBO_ERR_DASHES_OR_DOCTYPE:
-      print_message (
-        output,
-        "Incorrectly opened comment; expected '--', 'DOCTYPE', or '[CDATA['"
-      );
-      break;
-    case GUMBO_ERR_PARSER:
-      handle_parser_error(&error->v.parser, output);
-      break;
-    case GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG:
-    case GUMBO_ERR_SELF_CLOSING_END_TAG:
-      print_message (
-        output,
-        "Tag cannot be self-closing");
-      break;
-    default:
-      print_message (
-        output,
-        "Tokenizer error with an unimplemented error message"
-      );
-      break;
-  }
-  gumbo_string_buffer_append_codepoint('.', output);
+  if (error->type < GUMBO_ERR_PARSER)
+    handle_tokenizer_error(error, output);
+  else
+    handle_parser_error(&error->v.parser, output);
+}
+
+size_t gumbo_error_to_string(const GumboError* error, char** output) {
+  GumboStringBuffer sb;
+  gumbo_string_buffer_init(&sb);
+  error_to_string(error, &sb);
+  *output = sb.data;
+  return sb.length;
 }
 
-void gumbo_caret_diagnostic_to_string (
+void caret_diagnostic_to_string (
   const GumboError* error,
   const char* source_text,
   size_t source_length,
   GumboStringBuffer* output
 ) {
-  gumbo_error_to_string(error, output);
+  error_to_string(error, output);
 
-  const char* line_start = find_prev_newline(source_text, error->original_text);
-  const char* line_end = find_next_newline(source_text + source_length, error->original_text);
+  const char* error_text = error->original_text.data;
+  const char* line_start = find_prev_newline(source_text, source_length, error_text);
+  const char* line_end = find_next_newline(source_text, source_length, error_text);
   GumboStringPiece original_line;
   original_line.data = line_start;
   original_line.length = line_end - line_start;
@@ -324,6 +575,19 @@ void gumbo_caret_diagnostic_to_string (
   gumbo_string_buffer_append_codepoint('\n', output);
 }
 
+size_t gumbo_caret_diagnostic_to_string (
+  const GumboError* error,
+  const char* source_text,
+  size_t source_length,
+  char **output
+) {
+  GumboStringBuffer sb;
+  gumbo_string_buffer_init(&sb);
+  caret_diagnostic_to_string(error, source_text, source_length, &sb);
+  *output = sb.data;
+  return sb.length;
+}
+
 void gumbo_print_caret_diagnostic (
   const GumboError* error,
   const char* source_text,
@@ -331,20 +595,21 @@ void gumbo_print_caret_diagnostic (
 ) {
   GumboStringBuffer text;
   gumbo_string_buffer_init(&text);
-  gumbo_caret_diagnostic_to_string(error, source_text, source_length, &text);
+  print_message (
+    &text,
+    "%lu:%lu: ",
+    (unsigned long)error->position.line,
+    (unsigned long)error->position.column
+  );
+
+  caret_diagnostic_to_string(error, source_text, source_length, &text);
   printf("%.*s", (int) text.length, text.data);
   gumbo_string_buffer_destroy(&text);
 }
 
 void gumbo_error_destroy(GumboError* error) {
-  if (
-    error->type == GUMBO_ERR_PARSER
-    || error->type == GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG
-    || error->type == GUMBO_ERR_SELF_CLOSING_END_TAG
-  ) {
+  if (error->type == GUMBO_ERR_PARSER) {
     gumbo_vector_destroy(&error->v.parser.tag_stack);
-  } else if (error->type == GUMBO_ERR_DUPLICATE_ATTR) {
-    gumbo_free((void*) error->v.duplicate_attr.name);
   }
   gumbo_free(error);
 }