nokogiri 1.13.10-java → 1.14.0.rc1-java

data/ext/nokogiri/xml_namespace.c

@@ -32,7 +32,6 @@ _xml_namespace_dealloc(void *ptr)
    * node set. see noko_xml_namespace_wrap().
    */
   xmlNsPtr ns = ptr;
-  NOKOGIRI_DEBUG_START(ns) ;
 
   if (ns->href) {
     xmlFree(DISCARD_CONST_QUAL_XMLCHAR(ns->href));
@@ -41,7 +40,6 @@ _xml_namespace_dealloc(void *ptr)
     xmlFree(DISCARD_CONST_QUAL_XMLCHAR(ns->prefix));
   }
   xmlFree(ns);
-  NOKOGIRI_DEBUG_END(ns) ;
 }
 
 #ifdef HAVE_RB_GC_LOCATION
@@ -76,10 +74,26 @@ static const rb_data_type_t nokogiri_xml_namespace_type_without_dealloc = {
 };
 
 /*
- * call-seq:
- *  prefix
+ *  :call-seq:
+ *    prefix() → String or nil
  *
- * Get the prefix for this namespace.  Returns +nil+ if there is no prefix.
+ *  Return the prefix for this Namespace, or +nil+ if there is no prefix (e.g., default namespace).
+ *
+ *  *Example*
+ *
+ *    doc = Nokogiri::XML.parse(<<~XML)
+ *      <?xml version="1.0"?>
+ *      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
+ *        <child1 foo="abc" noko:bar="def"/>
+ *        <noko:child2 foo="qwe" noko:bar="rty"/>
+ *      </root>
+ *    XML
+ *
+ *    doc.root.elements.first.namespace.prefix
+ *    # => nil
+ *
+ *    doc.root.elements.last.namespace.prefix
+ *    # => "noko"
  */
 static VALUE
 prefix(VALUE self)
@@ -93,10 +107,26 @@ prefix(VALUE self)
 }
 
 /*
- * call-seq:
- *  href
+ *  :call-seq:
+ *    href() → String
+ *
+ *  Returns the URI reference for this Namespace.
+ *
+ *  *Example*
+ *
+ *    doc = Nokogiri::XML.parse(<<~XML)
+ *      <?xml version="1.0"?>
+ *      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
+ *        <child1 foo="abc" noko:bar="def"/>
+ *        <noko:child2 foo="qwe" noko:bar="rty"/>
+ *      </root>
+ *    XML
+ *
+ *    doc.root.elements.first.namespace.href
+ *    # => "http://nokogiri.org/ns/default"
  *
- * Get the href for this namespace
+ *    doc.root.elements.last.namespace.href
+ *    # => "http://nokogiri.org/ns/noko"
  */
 static VALUE
 href(VALUE self)

data/ext/nokogiri/xml_node.c

@@ -1,5 +1,7 @@
 #include <nokogiri.h>
 
+#include <stdbool.h>
+
 // :stopdoc:
 
 VALUE cNokogiriXmlNode ;
@@ -7,20 +9,11 @@ static ID id_decorate, id_decorate_bang;
 
 typedef xmlNodePtr(*pivot_reparentee_func)(xmlNodePtr, xmlNodePtr);
 
-#ifdef DEBUG
 static void
-_xml_node_dealloc(xmlNodePtr x)
+_xml_node_mark(void *ptr)
 {
-  NOKOGIRI_DEBUG_START(x)
-  NOKOGIRI_DEBUG_END(x)
-}
-#else
-#  define _xml_node_dealloc 0
-#endif
+  xmlNodePtr node = ptr;
 
-static void
-_xml_node_mark(xmlNodePtr node)
-{
   if (!DOC_RUBY_OBJECT_TEST(node->doc)) {
     return;
   }
@@ -37,24 +30,21 @@ _xml_node_mark(xmlNodePtr node)
 
 #ifdef HAVE_RB_GC_LOCATION
 static void
-_xml_node_update_references(xmlNodePtr node)
+_xml_node_update_references(void *ptr)
 {
+  xmlNodePtr node = ptr;
+
   if (node->_private) {
     node->_private = (void *)rb_gc_location((VALUE)node->_private);
   }
 }
+#else
+#  define _xml_node_update_references 0
 #endif
 
-typedef void (*gc_callback_t)(void *);
-
 static const rb_data_type_t nokogiri_node_type = {
   "Nokogiri/XMLNode",
-  {
-    (gc_callback_t)_xml_node_mark, (gc_callback_t)_xml_node_dealloc, 0,
-#ifdef HAVE_RB_GC_LOCATION
-    (gc_callback_t)_xml_node_update_references
-#endif
-  },
+  {_xml_node_mark, 0, 0, _xml_node_update_references},
   0, 0,
 #ifdef RUBY_TYPED_FREE_IMMEDIATELY
   RUBY_TYPED_FREE_IMMEDIATELY,
@@ -809,7 +799,7 @@ rb_xml_node_pointer_id(VALUE self)
   xmlNodePtr node;
   Noko_Node_Get_Struct(self, xmlNode, node);
 
-  return INT2NUM((long)(node));
+  return rb_uint2inum((uintptr_t)(node));
 }
 
 /*
@@ -1509,7 +1499,7 @@ node_type(VALUE self)
 {
   xmlNodePtr node;
   Noko_Node_Get_Struct(self, xmlNode, node);
-  return INT2NUM((long)node->type);
+  return INT2NUM(node->type);
 }
 
 /*
@@ -1724,6 +1714,269 @@ native_write_to(
   return io;
 }
 
+
+static inline void
+output_partial_string(VALUE out, char const *str, size_t length)
+{
+  if (length) {
+    rb_enc_str_buf_cat(out, str, (long)length, rb_utf8_encoding());
+  }
+}
+
+static inline void
+output_char(VALUE out, char ch)
+{
+  output_partial_string(out, &ch, 1);
+}
+
+static inline void
+output_string(VALUE out, char const *str)
+{
+  output_partial_string(out, str, strlen(str));
+}
+
+static inline void
+output_tagname(VALUE out, xmlNodePtr elem)
+{
+  // Elements in the HTML, MathML, and SVG namespaces do not use a namespace
+  // prefix in the HTML syntax.
+  char const *name = (char const *)elem->name;
+  xmlNsPtr ns = elem->ns;
+  if (ns && ns->href && ns->prefix
+      && strcmp((char const *)ns->href, "http://www.w3.org/1999/xhtml")
+      && strcmp((char const *)ns->href, "http://www.w3.org/1998/Math/MathML")
+      && strcmp((char const *)ns->href, "http://www.w3.org/2000/svg")) {
+    output_string(out, (char const *)elem->ns->prefix);
+    output_char(out, ':');
+    char const *colon = strchr(name, ':');
+    if (colon) {
+      name = colon + 1;
+    }
+  }
+  output_string(out, name);
+}
+
+static inline void
+output_attr_name(VALUE out, xmlAttrPtr attr)
+{
+  xmlNsPtr ns = attr->ns;
+  char const *name = (char const *)attr->name;
+  if (ns && ns->href) {
+    char const *uri = (char const *)ns->href;
+    char const *localname = strchr(name, ':');
+    if (localname) {
+      ++localname;
+    } else {
+      localname = name;
+    }
+
+    if (!strcmp(uri, "http://www.w3.org/XML/1998/namespace")) {
+      output_string(out, "xml:");
+      name = localname;
+    } else if (!strcmp(uri, "http://www.w3.org/2000/xmlns/")) {
+      // xmlns:xmlns -> xmlns
+      // xmlns:foo -> xmlns:foo
+      if (strcmp(localname, "xmlns")) {
+        output_string(out, "xmlns:");
+      }
+      name = localname;
+    } else if (!strcmp(uri, "http://www.w3.org/1999/xlink")) {
+      output_string(out, "xlink:");
+      name = localname;
+    } else if (ns->prefix) {
+      output_string(out, (char const *)ns->prefix);
+      output_char(out, ':');
+      name = localname;
+    }
+  }
+  output_string(out, name);
+}
+
+static void
+output_escaped_string(VALUE out, xmlChar const *start, bool attr)
+{
+  xmlChar const *next = start;
+  int ch;
+
+  while ((ch = *next) != 0) {
+    char const *replacement = NULL;
+    size_t replaced_bytes = 1;
+    if (ch == '&') {
+      replacement = "&amp;";
+    } else if (ch == 0xC2 && next[1] == 0xA0) {
+      // U+00A0 NO-BREAK SPACE has the UTF-8 encoding C2 A0.
+      replacement = "&nbsp;";
+      replaced_bytes = 2;
+    } else if (attr && ch == '"') {
+      replacement = "&quot;";
+    } else if (!attr && ch == '<') {
+      replacement = "&lt;";
+    } else if (!attr && ch == '>') {
+      replacement = "&gt;";
+    } else {
+      ++next;
+      continue;
+    }
+    output_partial_string(out, (char const *)start, next - start);
+    output_string(out, replacement);
+    next += replaced_bytes;
+    start = next;
+  }
+  output_partial_string(out, (char const *)start, next - start);
+}
+
+static bool
+should_prepend_newline(xmlNodePtr node)
+{
+  char const *name = (char const *)node->name;
+  xmlNodePtr child = node->children;
+
+  if (!name || !child || (strcmp(name, "pre") && strcmp(name, "textarea") && strcmp(name, "listing"))) {
+    return false;
+  }
+
+  return child->type == XML_TEXT_NODE && child->content && child->content[0] == '\n';
+}
+
+static VALUE
+rb_prepend_newline(VALUE self)
+{
+  xmlNodePtr node;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  return should_prepend_newline(node) ? Qtrue : Qfalse;
+}
+
+static bool
+is_one_of(xmlNodePtr node, char const *const *tagnames, size_t num_tagnames)
+{
+  char const *name = (char const *)node->name;
+  if (name == NULL) { // fragments don't have a name
+    return false;
+  }
+  for (size_t idx = 0; idx < num_tagnames; ++idx) {
+    if (!strcmp(name, tagnames[idx])) {
+      return true;
+    }
+  }
+  return false;
+
+}
+
+static void
+output_node(
+  VALUE out,
+  xmlNodePtr node,
+  bool preserve_newline
+)
+{
+  static char const *const VOID_ELEMENTS[] = {
+    "area", "base", "basefont", "bgsound", "br", "col", "embed", "frame", "hr",
+    "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr",
+  };
+
+  static char const *const UNESCAPED_TEXT_ELEMENTS[] = {
+    "style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext", "noscript",
+  };
+
+  switch (node->type) {
+    case XML_ELEMENT_NODE:
+      // Serialize the start tag.
+      output_char(out, '<');
+      output_tagname(out, node);
+
+      // Add attributes.
+      for (xmlAttrPtr attr = node->properties; attr; attr = attr->next) {
+        output_char(out, ' ');
+        output_attr_name(out, attr);
+        if (attr->children) {
+          output_string(out, "=\"");
+          xmlChar *value = xmlNodeListGetString(attr->doc, attr->children, 1);
+          output_escaped_string(out, value, true);
+          xmlFree(value);
+          output_char(out, '"');
+        } else {
+          // Output name=""
+          output_string(out, "=\"\"");
+        }
+      }
+      output_char(out, '>');
+
+      // Add children and end tag if element is not void.
+      if (!is_one_of(node, VOID_ELEMENTS, sizeof VOID_ELEMENTS / sizeof VOID_ELEMENTS[0])) {
+        if (preserve_newline && should_prepend_newline(node)) {
+          output_char(out, '\n');
+        }
+        for (xmlNodePtr child = node->children; child; child = child->next) {
+          output_node(out, child, preserve_newline);
+        }
+        output_string(out, "</");
+        output_tagname(out, node);
+        output_char(out, '>');
+      }
+      break;
+
+    case XML_TEXT_NODE:
+      if (node->parent
+          && is_one_of(node->parent, UNESCAPED_TEXT_ELEMENTS,
+                       sizeof UNESCAPED_TEXT_ELEMENTS / sizeof UNESCAPED_TEXT_ELEMENTS[0])) {
+        output_string(out, (char const *)node->content);
+      } else {
+        output_escaped_string(out, node->content, false);
+      }
+      break;
+
+    case XML_CDATA_SECTION_NODE:
+      output_string(out, "<![CDATA[");
+      output_string(out, (char const *)node->content);
+      output_string(out, "]]>");
+      break;
+
+    case XML_COMMENT_NODE:
+      output_string(out, "<!--");
+      output_string(out, (char const *)node->content);
+      output_string(out, "-->");
+      break;
+
+    case XML_PI_NODE:
+      output_string(out, "<?");
+      output_string(out, (char const *)node->content);
+      output_char(out, '>');
+      break;
+
+    case XML_DOCUMENT_TYPE_NODE:
+    case XML_DTD_NODE:
+      output_string(out, "<!DOCTYPE ");
+      output_string(out, (char const *)node->name);
+      output_string(out, ">");
+      break;
+
+    case XML_DOCUMENT_NODE:
+    case XML_DOCUMENT_FRAG_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      for (xmlNodePtr child = node->children; child; child = child->next) {
+        output_node(out, child, preserve_newline);
+      }
+      break;
+
+    default:
+      rb_raise(rb_eRuntimeError, "Unsupported document node (%d); this is a bug in Nokogiri", node->type);
+      break;
+  }
+}
+
+static VALUE
+html_standard_serialize(
+  VALUE self,
+  VALUE preserve_newline
+)
+{
+  xmlNodePtr node;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  VALUE output = rb_str_buf_new(4096);
+  output_node(output, node, RTEST(preserve_newline));
+  return output;
+}
+
 /*
  * :call-seq:
  *   line() → Integer
@@ -1757,7 +2010,7 @@ rb_xml_node_line(VALUE rb_node)
   xmlNodePtr c_node;
   Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  return INT2NUM(xmlGetLineNo(c_node));
+  return LONG2NUM(xmlGetLineNo(c_node));
 }
 
 /*
@@ -1860,7 +2113,7 @@ compare(VALUE self, VALUE _other)
   Noko_Node_Get_Struct(self, xmlNode, node);
   Noko_Node_Get_Struct(_other, xmlNode, other);
 
-  return INT2NUM((long)xmlXPathCmpNodes(other, node));
+  return INT2NUM(xmlXPathCmpNodes(other, node));
 }
 
 
@@ -1960,12 +2213,17 @@ in_context(VALUE self, VALUE _str, VALUE _options)
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 
-  /* Workaround for a libxml2 bug where a parsing error may leave a broken
+  /*
+   * Workaround for a libxml2 bug where a parsing error may leave a broken
    * node reference in node->doc->children.
+   *
+   * https://bugzilla.gnome.org/show_bug.cgi?id=668155
+   *
    * This workaround is limited to when a parse error occurs, the document
    * went from having no children to having children, and the context node is
    * part of a document fragment.
-   * https://bugzilla.gnome.org/show_bug.cgi?id=668155
+   *
+   * TODO: This was fixed in libxml 2.8.0 by 71a243d
    */
   if (error != XML_ERR_OK && doc_is_empty && node->doc->children != NULL) {
     child_iter = node;
@@ -2155,6 +2413,8 @@ noko_init_xml_node()
   rb_define_private_method(cNokogiriXmlNode, "get", get, 1);
   rb_define_private_method(cNokogiriXmlNode, "in_context", in_context, 2);
   rb_define_private_method(cNokogiriXmlNode, "native_write_to", native_write_to, 4);
+  rb_define_private_method(cNokogiriXmlNode, "prepend_newline?", rb_prepend_newline, 0);
+  rb_define_private_method(cNokogiriXmlNode, "html_standard_serialize", html_standard_serialize, 1);
   rb_define_private_method(cNokogiriXmlNode, "process_xincludes", process_xincludes, 1);
   rb_define_private_method(cNokogiriXmlNode, "replace_node", replace, 1);
   rb_define_private_method(cNokogiriXmlNode, "set", set, 2);

data/ext/nokogiri/xml_node_set.c

@@ -88,13 +88,11 @@ deallocate(xmlNodeSetPtr node_set)
    * For reasons outlined in xml_namespace.c, here we reproduce xmlXPathFreeNodeSet() except for the
    * offending call to xmlXPathNodeSetFreeNs().
    */
-  NOKOGIRI_DEBUG_START(node_set) ;
   if (node_set->nodeTab != NULL) {
     xmlFree(node_set->nodeTab);
   }
 
   xmlFree(node_set);
-  NOKOGIRI_DEBUG_END(node_set) ;
 }
 
 

data/ext/nokogiri/xml_reader.c

@@ -5,9 +5,7 @@ VALUE cNokogiriXmlReader;
 static void
 dealloc(xmlTextReaderPtr reader)
 {
-  NOKOGIRI_DEBUG_START(reader);
   xmlFreeTextReader(reader);
-  NOKOGIRI_DEBUG_END(reader);
 }
 
 static int
@@ -126,26 +124,37 @@ attributes_eh(VALUE self)
  * Get a hash of namespaces for this Node
  */
 static VALUE
-namespaces(VALUE self)
+rb_xml_reader_namespaces(VALUE rb_reader)
 {
-  xmlTextReaderPtr reader;
-  xmlNodePtr ptr;
-  VALUE attr ;
-
-  Data_Get_Struct(self, xmlTextReader, reader);
+  VALUE rb_namespaces = rb_hash_new() ;
+  xmlTextReaderPtr c_reader;
+  xmlNodePtr c_node;
+  VALUE rb_errors;
 
-  attr = rb_hash_new() ;
+  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
 
-  if (! has_attributes(reader)) {
-    return attr ;
+  if (! has_attributes(c_reader)) {
+    return rb_namespaces ;
   }
 
-  ptr = xmlTextReaderExpand(reader);
-  if (ptr == NULL) { return Qnil; }
+  rb_errors = rb_funcall(rb_reader, rb_intern("errors"), 0);
 
-  Nokogiri_xml_node_namespaces(ptr, attr);
+  xmlSetStructuredErrorFunc((void *)rb_errors, Nokogiri_error_array_pusher);
+  c_node = xmlTextReaderExpand(c_reader);
+  xmlSetStructuredErrorFunc(NULL, NULL);
 
-  return attr ;
+  if (c_node == NULL) {
+    if (RARRAY_LEN(rb_errors) > 0) {
+      VALUE rb_error = rb_ary_entry(rb_errors, 0);
+      VALUE exception_message = rb_funcall(rb_error, rb_intern("to_s"), 0);
+      rb_exc_raise(rb_class_new_instance(1, &exception_message, cNokogiriXmlSyntaxError));
+    }
+    return Qnil;
+  }
+
+  Nokogiri_xml_node_namespaces(c_node, rb_namespaces);
+
+  return rb_namespaces ;
 }
 
 /*
@@ -204,6 +213,7 @@ rb_xml_reader_attribute_hash(VALUE rb_reader)
   xmlTextReaderPtr c_reader;
   xmlNodePtr c_node;
   xmlAttrPtr c_property;
+  VALUE rb_errors;
 
   Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
 
@@ -211,8 +221,18 @@ rb_xml_reader_attribute_hash(VALUE rb_reader)
     return rb_attributes;
   }
 
+  rb_errors = rb_funcall(rb_reader, rb_intern("errors"), 0);
+
+  xmlSetStructuredErrorFunc((void *)rb_errors, Nokogiri_error_array_pusher);
   c_node = xmlTextReaderExpand(c_reader);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
   if (c_node == NULL) {
+    if (RARRAY_LEN(rb_errors) > 0) {
+      VALUE rb_error = rb_ary_entry(rb_errors, 0);
+      VALUE exception_message = rb_funcall(rb_error, rb_intern("to_s"), 0);
+      rb_exc_raise(rb_class_new_instance(1, &exception_message, cNokogiriXmlSyntaxError));
+    }
     return Qnil;
   }
 
@@ -306,7 +326,7 @@ attribute_count(VALUE self)
   count = xmlTextReaderAttributeCount(reader);
   if (count == -1) { return Qnil; }
 
-  return INT2NUM((long)count);
+  return INT2NUM(count);
 }
 
 /*
@@ -325,7 +345,7 @@ depth(VALUE self)
   depth = xmlTextReaderDepth(reader);
   if (depth == -1) { return Qnil; }
 
-  return INT2NUM((long)depth);
+  return INT2NUM(depth);
 }
 
 /*
@@ -498,7 +518,7 @@ state(VALUE self)
 {
   xmlTextReaderPtr reader;
   Data_Get_Struct(self, xmlTextReader, reader);
-  return INT2NUM((long)xmlTextReaderReadState(reader));
+  return INT2NUM(xmlTextReaderReadState(reader));
 }
 
 /*
@@ -512,7 +532,7 @@ node_type(VALUE self)
 {
   xmlTextReaderPtr reader;
   Data_Get_Struct(self, xmlTextReader, reader);
-  return INT2NUM((long)xmlTextReaderNodeType(reader));
+  return INT2NUM(xmlTextReaderNodeType(reader));
 }
 
 /*
@@ -762,7 +782,7 @@ noko_init_xml_reader()
   rb_define_method(cNokogiriXmlReader, "local_name", local_name, 0);
   rb_define_method(cNokogiriXmlReader, "name", name, 0);
   rb_define_method(cNokogiriXmlReader, "namespace_uri", namespace_uri, 0);
-  rb_define_method(cNokogiriXmlReader, "namespaces", namespaces, 0);
+  rb_define_method(cNokogiriXmlReader, "namespaces", rb_xml_reader_namespaces, 0);
   rb_define_method(cNokogiriXmlReader, "node_type", node_type, 0);
   rb_define_method(cNokogiriXmlReader, "outer_xml", outer_xml, 0);
   rb_define_method(cNokogiriXmlReader, "prefix", prefix, 0);

data/ext/nokogiri/xml_relax_ng.c

@@ -5,9 +5,7 @@ VALUE cNokogiriXmlRelaxNG;
 static void
 dealloc(xmlRelaxNGPtr schema)
 {
-  NOKOGIRI_DEBUG_START(schema);
   xmlRelaxNGFree(schema);
-  NOKOGIRI_DEBUG_END(schema);
 }
 
 /*

data/ext/nokogiri/xml_sax_parser.c

@@ -195,40 +195,48 @@ comment_func(void *ctx, const xmlChar *value)
   rb_funcall(doc, id_comment, 1, str);
 }
 
+PRINTFLIKE_DECL(2, 3)
 static void
 warning_func(void *ctx, const char *msg, ...)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
-  char *message;
-  VALUE ruby_message;
+  VALUE rb_message;
 
+#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("warning_func: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  rb_message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  ruby_message = NOKOGIRI_STR_NEW2(message);
-  free(message);
-  rb_funcall(doc, id_warning, 1, ruby_message);
+  rb_funcall(doc, id_warning, 1, rb_message);
 }
 
+PRINTFLIKE_DECL(2, 3)
 static void
 error_func(void *ctx, const char *msg, ...)
 {
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
-  char *message;
-  VALUE ruby_message;
+  VALUE rb_message;
 
+#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("error_func: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  rb_message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  ruby_message = NOKOGIRI_STR_NEW2(message);
-  free(message);
-  rb_funcall(doc, id_error, 1, ruby_message);
+  rb_funcall(doc, id_error, 1, rb_message);
 }
 
 static void
@@ -260,15 +268,13 @@ processing_instruction(void *ctx, const xmlChar *name, const xmlChar *content)
 static void
 deallocate(xmlSAXHandlerPtr handler)
 {
-  NOKOGIRI_DEBUG_START(handler);
-  free(handler);
-  NOKOGIRI_DEBUG_END(handler);
+  ruby_xfree(handler);
 }
 
 static VALUE
 allocate(VALUE klass)
 {
-  xmlSAXHandlerPtr handler = calloc((size_t)1, sizeof(xmlSAXHandler));
+  xmlSAXHandlerPtr handler = ruby_xcalloc((size_t)1, sizeof(xmlSAXHandler));
 
   handler->startDocument = start_document;
   handler->endDocument = end_document;