nokogiri 1.16.8 → 1.18.2

data/ext/nokogiri/xml_xpath_context.c

@@ -12,23 +12,23 @@ static const xmlChar *NOKOGIRI_BUILTIN_PREFIX = (const xmlChar *)"nokogiri-built
 static const xmlChar *NOKOGIRI_BUILTIN_URI = (const xmlChar *)"https://www.nokogiri.org/default_ns/ruby/builtins";
 
 static void
-xml_xpath_context_deallocate(void *data)
+_noko_xml_xpath_context_dfree(void *data)
 {
   xmlXPathContextPtr c_context = data;
   xmlXPathFreeContext(c_context);
 }
 
-static const rb_data_type_t xml_xpath_context_type = {
-  .wrap_struct_name = "Nokogiri::XML::XPathContext",
+static const rb_data_type_t _noko_xml_xpath_context_type = {
+  .wrap_struct_name = "xmlXPathContext",
   .function = {
-    .dfree = xml_xpath_context_deallocate,
+    .dfree = _noko_xml_xpath_context_dfree,
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 /* find a CSS class in an HTML element's `class` attribute */
 static const xmlChar *
-builtin_css_class(const xmlChar *str, const xmlChar *val)
+_noko_xml_xpath_context__css_class(const xmlChar *str, const xmlChar *val)
 {
   int val_len;
 
@@ -62,9 +62,9 @@ builtin_css_class(const xmlChar *str, const xmlChar *val)
   return (NULL);
 }
 
-/* xmlXPathFunction to wrap builtin_css_class() */
+/* xmlXPathFunction to wrap _noko_xml_xpath_context__css_class() */
 static void
-xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
+noko_xml_xpath_context_xpath_func_css_class(xmlXPathParserContextPtr ctxt, int nargs)
 {
   xmlXPathObjectPtr hay, needle;
 
@@ -85,7 +85,7 @@ xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
     XP_ERROR(XPATH_INVALID_TYPE);
   }
 
-  if (builtin_css_class(hay->stringval, needle->stringval)) {
+  if (_noko_xml_xpath_context__css_class(hay->stringval, needle->stringval)) {
     valuePush(ctxt, xmlXPathNewBoolean(1));
   } else {
     valuePush(ctxt, xmlXPathNewBoolean(0));
@@ -99,7 +99,7 @@ xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
 /* xmlXPathFunction to select nodes whose local name matches, for HTML5 CSS queries that should
  * ignore namespaces */
 static void
-xpath_builtin_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
+noko_xml_xpath_context_xpath_func_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
 {
   xmlXPathObjectPtr element_name;
 
@@ -124,25 +124,26 @@ xpath_builtin_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
  *   register_ns(prefix, uri) → Nokogiri::XML::XPathContext
  *
  * Register the namespace with +prefix+ and +uri+ for use in future queries.
+ * Passing a uri of +nil+ will unregister the namespace.
  *
  * [Returns] +self+
  */
 static VALUE
-rb_xml_xpath_context_register_ns(VALUE rb_context, VALUE prefix, VALUE uri)
+noko_xml_xpath_context_register_ns(VALUE rb_context, VALUE prefix, VALUE uri)
 {
   xmlXPathContextPtr c_context;
+  const xmlChar *ns_uri;
 
-  TypedData_Get_Struct(
-    rb_context,
-    xmlXPathContext,
-    &xml_xpath_context_type,
-    c_context
-  );
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
+
+  if (NIL_P(uri)) {
+    ns_uri = NULL;
+  } else {
+    ns_uri = (const xmlChar *)StringValueCStr(uri);
+  }
+
+  xmlXPathRegisterNs(c_context, (const xmlChar *)StringValueCStr(prefix), ns_uri);
 
-  xmlXPathRegisterNs(c_context,
-                     (const xmlChar *)StringValueCStr(prefix),
-                     (const xmlChar *)StringValueCStr(uri)
-                    );
   return rb_context;
 }
 
@@ -151,29 +152,25 @@ rb_xml_xpath_context_register_ns(VALUE rb_context, VALUE prefix, VALUE uri)
  *   register_variable(name, value) → Nokogiri::XML::XPathContext
  *
  * Register the variable +name+ with +value+ for use in future queries.
+ * Passing a value of +nil+ will unregister the variable.
  *
  * [Returns] +self+
  */
 static VALUE
-rb_xml_xpath_context_register_variable(VALUE rb_context, VALUE name, VALUE value)
+noko_xml_xpath_context_register_variable(VALUE rb_context, VALUE name, VALUE value)
 {
   xmlXPathContextPtr c_context;
   xmlXPathObjectPtr xmlValue;
 
-  TypedData_Get_Struct(
-    rb_context,
-    xmlXPathContext,
-    &xml_xpath_context_type,
-    c_context
-  );
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
 
-  xmlValue = xmlXPathNewCString(StringValueCStr(value));
+  if (NIL_P(value)) {
+    xmlValue = NULL;
+  } else {
+    xmlValue = xmlXPathNewCString(StringValueCStr(value));
+  }
 
-  xmlXPathRegisterVariable(
-    c_context,
-    (const xmlChar *)StringValueCStr(name),
-    xmlValue
-  );
+  xmlXPathRegisterVariable(c_context, (const xmlChar *)StringValueCStr(name), xmlValue);
 
   return rb_context;
 }
@@ -184,7 +181,7 @@ rb_xml_xpath_context_register_variable(VALUE rb_context, VALUE name, VALUE value
  *  returns Qundef if no conversion was possible.
  */
 static VALUE
-xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr c_context)
+_noko_xml_xpath_context__xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr c_context)
 {
   VALUE rb_retval;
 
@@ -238,7 +235,7 @@ Nokogiri_marshal_xpath_funcall_and_return_values(
 
   for (int j = argc - 1 ; j >= 0 ; --j) {
     c_xpath_object = valuePop(ctxt);
-    argv[j] = xpath2ruby(c_xpath_object, ctxt->context);
+    argv[j] = _noko_xml_xpath_context__xpath2ruby(c_xpath_object, ctxt->context);
     if (argv[j] == Qundef) {
       argv[j] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(c_xpath_object));
     }
@@ -294,7 +291,7 @@ Nokogiri_marshal_xpath_funcall_and_return_values(
 }
 
 static void
-method_caller(xmlXPathParserContextPtr ctxt, int argc)
+_noko_xml_xpath_context__handler_invoker(xmlXPathParserContextPtr ctxt, int argc)
 {
   VALUE rb_xpath_handler = Qnil;
   const char *method_name = NULL ;
@@ -316,15 +313,15 @@ method_caller(xmlXPathParserContextPtr ctxt, int argc)
 }
 
 static xmlXPathFunction
-handler_lookup(void *data, const xmlChar *c_name, const xmlChar *c_ns_uri)
+_noko_xml_xpath_context_handler_lookup(void *data, const xmlChar *c_name, const xmlChar *c_ns_uri)
 {
   VALUE rb_handler = (VALUE)data;
   if (rb_respond_to(rb_handler, rb_intern((const char *)c_name))) {
     if (c_ns_uri == NULL) {
       NOKO_WARN_DEPRECATION("A custom XPath or CSS handler function named '%s' is being invoked without a namespace. Please update your query to reference this function as 'nokogiri:%s'. Invoking custom handler functions without a namespace is deprecated and will become an error in Nokogiri v1.17.0.",
-                            c_name, c_name); // deprecated in v1.15.0, remove in v1.17.0
+                            c_name, c_name); // TODO deprecated in v1.15.0, remove in v1.19.0
     }
-    return method_caller;
+    return _noko_xml_xpath_context__handler_invoker;
   }
 
   return NULL;
@@ -332,7 +329,7 @@ handler_lookup(void *data, const xmlChar *c_name, const xmlChar *c_ns_uri)
 
 PRINTFLIKE_DECL(2, 3)
 static void
-generic_exception_pusher(void *data, const char *msg, ...)
+_noko_xml_xpath_context__generic_exception_pusher(void *data, const char *msg, ...)
 {
   VALUE rb_errors = (VALUE)data;
   VALUE rb_message;
@@ -343,7 +340,7 @@ generic_exception_pusher(void *data, const char *msg, ...)
 #ifdef TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
   /* It is not currently possible to pass var args from native
      functions to sulong, so we work around the issue here. */
-  rb_message = rb_sprintf("generic_exception_pusher: %s", msg);
+  rb_message = rb_sprintf("_noko_xml_xpath_context__generic_exception_pusher: %s", msg);
 #else
   va_list args;
   va_start(args, msg);
@@ -365,58 +362,55 @@ generic_exception_pusher(void *data, const char *msg, ...)
  * a +Float+, or a boolean.
  */
 static VALUE
-rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE rb_context)
+noko_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE rb_context)
 {
-  VALUE search_path, xpath_handler;
-  VALUE retval = Qnil;
   xmlXPathContextPtr c_context;
-  xmlXPathObjectPtr xpath;
-  xmlChar *query;
-  VALUE errors = rb_ary_new();
-
-  TypedData_Get_Struct(
-    rb_context,
-    xmlXPathContext,
-    &xml_xpath_context_type,
-    c_context
-  );
+  VALUE rb_expression = Qnil;
+  VALUE rb_function_lookup_handler = Qnil;
+  xmlChar *c_expression_str = NULL;
+  VALUE rb_errors = rb_ary_new();
+  xmlXPathObjectPtr c_xpath_object;
+  VALUE rb_xpath_object = Qnil;
 
-  if (rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1) {
-    xpath_handler = Qnil;
-  }
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
+
+  rb_scan_args(argc, argv, "11", &rb_expression, &rb_function_lookup_handler);
 
-  query = (xmlChar *)StringValueCStr(search_path);
+  c_expression_str = (xmlChar *)StringValueCStr(rb_expression);
 
-  if (Qnil != xpath_handler) {
+  if (Qnil != rb_function_lookup_handler) {
     /* FIXME: not sure if this is the correct place to shove private data. */
-    c_context->userData = (void *)xpath_handler;
+    c_context->userData = (void *)rb_function_lookup_handler;
     xmlXPathRegisterFuncLookup(
       c_context,
-      handler_lookup,
-      (void *)xpath_handler
+      _noko_xml_xpath_context_handler_lookup,
+      (void *)rb_function_lookup_handler
     );
   }
 
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
-  xmlSetGenericErrorFunc((void *)errors, generic_exception_pusher);
+  /* TODO: use xmlXPathSetErrorHandler (as of 2.13.0) */
+  xmlSetStructuredErrorFunc((void *)rb_errors, noko__error_array_pusher);
+  xmlSetGenericErrorFunc((void *)rb_errors, _noko_xml_xpath_context__generic_exception_pusher);
 
-  xpath = xmlXPathEvalExpression(query, c_context);
+  c_xpath_object = xmlXPathEvalExpression(c_expression_str, c_context);
 
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
 
-  if (xpath == NULL) {
-    rb_exc_raise(rb_ary_entry(errors, 0));
+  xmlXPathRegisterFuncLookup(c_context, NULL, NULL);
+
+  if (c_xpath_object == NULL) {
+    rb_exc_raise(rb_ary_entry(rb_errors, 0));
   }
 
-  retval = xpath2ruby(xpath, c_context);
-  if (retval == Qundef) {
-    retval = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(c_context->doc));
+  rb_xpath_object = _noko_xml_xpath_context__xpath2ruby(c_xpath_object, c_context);
+  if (rb_xpath_object == Qundef) {
+    rb_xpath_object = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(c_context->doc));
   }
 
-  xmlXPathFreeNodeSetList(xpath);
+  xmlXPathFreeNodeSetList(c_xpath_object);
 
-  return retval;
+  return rb_xpath_object;
 }
 
 /*
@@ -426,45 +420,53 @@ rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE rb_context)
  * Create a new XPathContext with +node+ as the context node.
  */
 static VALUE
-rb_xml_xpath_context_new(VALUE klass, VALUE rb_node)
+noko_xml_xpath_context_new(VALUE klass, VALUE rb_node)
 {
-  xmlNodePtr node;
+  xmlNodePtr c_node;
   xmlXPathContextPtr c_context;
   VALUE rb_context;
 
-  Noko_Node_Get_Struct(rb_node, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
 #if LIBXML_VERSION < 21000
-  /* deprecated in 40483d0 */
-  xmlXPathInit();
+  xmlXPathInit(); /* deprecated in 40483d0 */
 #endif
 
-  c_context = xmlXPathNewContext(node->doc);
-  c_context->node = node;
+  c_context = xmlXPathNewContext(c_node->doc);
+  c_context->node = c_node;
 
   xmlXPathRegisterNs(c_context, NOKOGIRI_PREFIX, NOKOGIRI_URI);
   xmlXPathRegisterNs(c_context, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
-  xmlXPathRegisterFuncNS(
-    c_context,
-    (const xmlChar *)"css-class",
-    NOKOGIRI_BUILTIN_URI,
-    xpath_builtin_css_class
-  );
-  xmlXPathRegisterFuncNS(
-    c_context,
-    (const xmlChar *)"local-name-is",
-    NOKOGIRI_BUILTIN_URI,
-    xpath_builtin_local_name_is
-  );
 
-  rb_context = TypedData_Wrap_Struct(
-                 klass,
-                 &xml_xpath_context_type,
-                 c_context
-               );
+  xmlXPathRegisterFuncNS(c_context,
+                         (const xmlChar *)"css-class", NOKOGIRI_BUILTIN_URI,
+                         noko_xml_xpath_context_xpath_func_css_class);
+  xmlXPathRegisterFuncNS(c_context,
+                         (const xmlChar *)"local-name-is", NOKOGIRI_BUILTIN_URI,
+                         noko_xml_xpath_context_xpath_func_local_name_is);
+
+  rb_context = TypedData_Wrap_Struct(klass, &_noko_xml_xpath_context_type, c_context);
+
   return rb_context;
 }
 
+
+/* :nodoc: */
+static VALUE
+noko_xml_xpath_context_set_node(VALUE rb_context, VALUE rb_node)
+{
+  xmlNodePtr c_node;
+  xmlXPathContextPtr c_context;
+
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
+
+  c_context->doc = c_node->doc;
+  c_context->node = c_node;
+
+  return rb_node;
+}
+
 void
 noko_init_xml_xpath_context(void)
 {
@@ -475,9 +477,10 @@ noko_init_xml_xpath_context(void)
 
   rb_undef_alloc_func(cNokogiriXmlXpathContext);
 
-  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", rb_xml_xpath_context_new, 1);
+  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", noko_xml_xpath_context_new, 1);
 
-  rb_define_method(cNokogiriXmlXpathContext, "evaluate", rb_xml_xpath_context_evaluate, -1);
-  rb_define_method(cNokogiriXmlXpathContext, "register_variable", rb_xml_xpath_context_register_variable, 2);
-  rb_define_method(cNokogiriXmlXpathContext, "register_ns", rb_xml_xpath_context_register_ns, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "evaluate", noko_xml_xpath_context_evaluate, -1);
+  rb_define_method(cNokogiriXmlXpathContext, "register_variable", noko_xml_xpath_context_register_variable, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "register_ns", noko_xml_xpath_context_register_ns, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "node=", noko_xml_xpath_context_set_node, 1);
 }

data/ext/nokogiri/xslt_stylesheet.c

@@ -1,6 +1,6 @@
 #include <nokogiri.h>
 
-VALUE cNokogiriXsltStylesheet ;
+VALUE cNokogiriXsltStylesheet;
 
 static void
 mark(void *data)
@@ -18,8 +18,8 @@ dealloc(void *data)
   ruby_xfree(wrapper);
 }
 
-static const rb_data_type_t xslt_stylesheet_type = {
-  .wrap_struct_name = "Nokogiri::XSLT::Stylesheet",
+static const rb_data_type_t nokogiri_xslt_stylesheet_tuple_type = {
+  .wrap_struct_name = "nokogiriXsltStylesheetTuple",
   .function = {
     .dmark = mark,
     .dfree = dealloc,
@@ -56,7 +56,7 @@ Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
   self = TypedData_Make_Struct(
            cNokogiriXsltStylesheet,
            nokogiriXsltStylesheetTuple,
-           &xslt_stylesheet_type,
+           &nokogiri_xslt_stylesheet_tuple_type,
            wrapper
          );
 
@@ -124,7 +124,7 @@ rb_xslt_stylesheet_serialize(VALUE self, VALUE xmlobj)
   TypedData_Get_Struct(
     self,
     nokogiriXsltStylesheetTuple,
-    &xslt_stylesheet_type,
+    &nokogiri_xslt_stylesheet_tuple_type,
     wrapper
   );
   xsltSaveResultToString(&doc_ptr, &doc_len, xml, wrapper->ss);
@@ -273,7 +273,7 @@ rb_xslt_stylesheet_transform(int argc, VALUE *argv, VALUE self)
   Check_Type(rb_param, T_ARRAY);
 
   c_document = noko_xml_document_unwrap(rb_document);
-  TypedData_Get_Struct(self, nokogiriXsltStylesheetTuple, &xslt_stylesheet_type, wrapper);
+  TypedData_Get_Struct(self, nokogiriXsltStylesheetTuple, &nokogiri_xslt_stylesheet_tuple_type, wrapper);
 
   param_len = RARRAY_LEN(rb_param);
   params = ruby_xcalloc((size_t)param_len + 1, sizeof(char *));
@@ -362,7 +362,7 @@ initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
   TypedData_Get_Struct(
     (VALUE)ctxt->style->_private,
     nokogiriXsltStylesheetTuple,
-    &xslt_stylesheet_type,
+    &nokogiri_xslt_stylesheet_tuple_type,
     wrapper
   );
   inst = rb_class_new_instance(0, NULL, obj);
@@ -380,7 +380,7 @@ shutdownFunc(xsltTransformContextPtr ctxt,
   TypedData_Get_Struct(
     (VALUE)ctxt->style->_private,
     nokogiriXsltStylesheetTuple,
-    &xslt_stylesheet_type,
+    &nokogiri_xslt_stylesheet_tuple_type,
     wrapper
   );
 

data/gumbo-parser/src/ascii.c

@@ -44,8 +44,8 @@ const unsigned char _gumbo_ascii_table[0x80] = {
 };
 
 // Table generation code.
-// clang -DGUMBO_GEN_TABLE=1 ascii.c && ./a.out && rm a.out
-#if GUMBO_GEN_TABLE
+// clang -DGUMBO_GEN_TABLE ascii.c && ./a.out && rm a.out
+#ifdef GUMBO_GEN_TABLE
 #include <stdio.h>
 
 int main() {

data/gumbo-parser/src/error.c

@@ -46,33 +46,40 @@ static int PRINTF(2) print_message (
     args
   );
   va_end(args);
-#if _MSC_VER && _MSC_VER < 1900
+
+#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(_RUBY_MSVCRT)
   if (bytes_written == -1) {
     // 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);
+    // there been enough. In this case, we can call vsnprintf() again but
+    // with a count of 0 to get the number of bytes written, not including
+    // the null terminator.
+    // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/vsnprintf-vsnprintf-vsnprintf-l-vsnwprintf-vsnwprintf-l?view=msvc-140#behavior-summary
+
     va_start(args, format);
-    int result = vsnprintf (
-      output->data + output->length,
-      remaining_capacity,
+    bytes_written = vsnprintf (
+      NULL,
+      0,
       format,
       args
     );
     va_end(args);
-    return result == -1 ? 0 : result;
   }
-#else
+#endif
+
   // -1 in standard C99 indicates an encoding error. Return 0 and do nothing.
   if (bytes_written == -1) {
     return 0;
   }
-#endif
 
   if (bytes_written >= remaining_capacity) {
-    gumbo_string_buffer_reserve(output->capacity + bytes_written, output);
+    // At least double the size of the buffer.
+    size_t new_capacity = output->capacity * 2;
+    if (new_capacity < output->length + bytes_written + 1) {
+      // The +1 is for the null terminator.
+      new_capacity = output->length + bytes_written + 1;
+    }
+    gumbo_string_buffer_reserve(new_capacity, output);
     remaining_capacity = output->capacity - output->length;
     va_start(args, format);
     bytes_written = vsnprintf (
@@ -96,8 +103,14 @@ static void print_tag_stack (
     if (i) {
       print_message(output, ", ");
     }
-    GumboTag tag = (GumboTag)(intptr_t) error->tag_stack.data[i];
-    print_message(output, "%s", gumbo_normalized_tagname(tag));
+    uintptr_t tag = (uintptr_t) error->tag_stack.data[i];
+    const char* tag_name;
+    if (tag > GUMBO_TAG_UNKNOWN) {
+      tag_name = error->tag_stack.data[i];
+    } else {
+      tag_name = gumbo_normalized_tagname((GumboTag)tag);
+    }
+    print_message(output, "%s", tag_name);
   }
   gumbo_string_buffer_append_codepoint('.', output);
 }
@@ -326,41 +339,45 @@ static void handle_parser_error (
   }
 
   switch (error->input_type) {
-    case GUMBO_TOKEN_DOCTYPE:
-      print_message(output, "This is not a legal doctype");
-      return;
-    case GUMBO_TOKEN_COMMENT:
-      // Should never happen; comments are always legal.
-      assert(0);
-      // But just in case...
-      print_message(output, "Comments aren't legal here");
-      return;
-    case GUMBO_TOKEN_CDATA:
-    case GUMBO_TOKEN_WHITESPACE:
-    case GUMBO_TOKEN_CHARACTER:
-      print_message(output, "Character tokens aren't legal here");
-      return;
-    case GUMBO_TOKEN_NULL:
-      print_message(output, "Null bytes are not allowed in HTML5");
-      return;
-    case GUMBO_TOKEN_EOF:
-      if (error->parser_state == GUMBO_INSERTION_MODE_INITIAL) {
-        print_message(output, "You must provide a doctype");
-      } else {
-        print_message(output, "Premature end of file.");
-        print_tag_stack(error, output);
-      }
-      return;
-    case GUMBO_TOKEN_START_TAG:
-      print_message(output, "Start tag '%s' isn't allowed here.",
-                    gumbo_normalized_tagname(error->input_tag));
-      print_tag_stack(error, output);
-      return;
-    case GUMBO_TOKEN_END_TAG:
-      print_message(output, "End tag '%s' isn't allowed here.",
-                    gumbo_normalized_tagname(error->input_tag));
+  case GUMBO_TOKEN_DOCTYPE:
+    print_message(output, "This is not a legal doctype");
+    return;
+  case GUMBO_TOKEN_COMMENT:
+    // Should never happen; comments are always legal.
+    assert(0);
+    // But just in case...
+    print_message(output, "Comments aren't legal here");
+    return;
+  case GUMBO_TOKEN_CDATA:
+  case GUMBO_TOKEN_WHITESPACE:
+  case GUMBO_TOKEN_CHARACTER:
+    print_message(output, "Character tokens aren't legal here");
+    return;
+  case GUMBO_TOKEN_NULL:
+    print_message(output, "Null bytes are not allowed in HTML5");
+    return;
+  case GUMBO_TOKEN_EOF:
+    if (error->parser_state == GUMBO_INSERTION_MODE_INITIAL) {
+      print_message(output, "You must provide a doctype");
+    } else {
+      print_message(output, "Premature end of file.");
       print_tag_stack(error, output);
-      return;
+    }
+    return;
+  case GUMBO_TOKEN_START_TAG:
+  case GUMBO_TOKEN_END_TAG:
+  {
+    const char* tag_name;
+    const char* which = error->input_type == GUMBO_TOKEN_START_TAG ? "Start" : "End";
+    if (error->input_name) {
+      tag_name = error->input_name;
+    } else {
+      tag_name = gumbo_normalized_tagname(error->input_tag);
+    }
+    print_message(output, "%s tag '%s' isn't allowed here.", which, tag_name);
+    print_tag_stack(error, output);
+    return;
+  }
   }
 }
 
@@ -613,6 +630,17 @@ void gumbo_print_caret_diagnostic (
 
 void gumbo_error_destroy(GumboError* error) {
   if (error->type == GUMBO_ERR_PARSER) {
+    // Free the tag name.
+    if (error->v.parser.input_name) {
+      gumbo_free(error->v.parser.input_name);
+    }
+
+    for (unsigned int i = 0; i < error->v.parser.tag_stack.length; ++i) {
+      intptr_t tag = (intptr_t) error->v.parser.tag_stack.data[i];
+      if (tag > GUMBO_TAG_UNKNOWN) {
+        gumbo_free(error->v.parser.tag_stack.data[i]);
+      }
+    }
     gumbo_vector_destroy(&error->v.parser.tag_stack);
   }
   gumbo_free(error);

data/gumbo-parser/src/error.h

@@ -95,12 +95,16 @@ typedef struct GumboInternalParserError {
   // The HTML tag of the input token. TAG_UNKNOWN if this was not a tag token.
   GumboTag input_tag;
 
+  // The HTML tag of the input token if it was nonstandard tag token. NULL otherwise.
+  char *input_name;
+
   // 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
   // of GumboTag's *stored by value* - cast the void* to an GumboTag directly to
-  // get at the tag.
+  // get at the tag. For nonstandard tags, this is a pointer to an owned char *
+  // containing the tag name.
   GumboVector /* GumboTag */ tag_stack;
 } GumboParserError;
 

data/gumbo-parser/src/nokogiri_gumbo.h

@@ -780,6 +780,15 @@ typedef struct GumboInternalOptions {
    * Default: `false`.
    */
   bool fragment_context_has_form_ancestor;
+
+  /**
+   * Parse `noscript` elements as if scripting was enabled. This causes the
+   * contents of the `noscript` element to be parsed as raw text, rather
+   * than as HTML elements.
+   * 
+   * Default: `false`.
+   */
+  bool parse_noscript_content_as_text;
 } GumboOptions;
 
 /** Default options struct; use this with gumbo_parse_with_options. */
@@ -791,7 +800,7 @@ extern const GumboOptions kGumboDefaultOptions;
  */
 typedef enum {
   /**
-   * Indicates that parsing completed successfuly. The resulting tree
+   * Indicates that parsing completed successfully. The resulting tree
    * will be a complete document.
    */
   GUMBO_STATUS_OK,
@@ -841,7 +850,7 @@ typedef struct GumboInternalOutput {
   GumboVector /* GumboError */ errors;
 
   /**
-   * True if the parser encounted an error.
+   * True if the parser encountered an error.
    *
    * This can be true and `errors` an empty `GumboVector` if the `max_errors`
    * option was set to 0.