libxml-ruby 5.0.6 → 6.0.0

data/ext/libxml/ruby_xml_html_parser_context.c

@@ -129,14 +129,21 @@ static htmlParserCtxtPtr htmlNewParserCtxt(void)
 }
 #endif
 
-static void rxml_html_parser_context_free(htmlParserCtxtPtr ctxt)
+static void rxml_html_parser_context_free(void* data)
 {
+  htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)data;
   htmlFreeParserCtxt(ctxt);
 }
 
+const rb_data_type_t rxml_html_parser_context_type = {
+  "LibXML::XML::HTMLParser::Context",
+  {NULL, rxml_html_parser_context_free, NULL},
+  &rxml_parser_context_type, NULL, 0
+};
+
 static VALUE rxml_html_parser_context_wrap(htmlParserCtxtPtr ctxt)
 {
-  return Data_Wrap_Struct(cXMLHtmlParserContext, NULL, rxml_html_parser_context_free, ctxt);
+  return TypedData_Wrap_Struct(cXMLHtmlParserContext, &rxml_html_parser_context_type, ctxt);
 }
 
 /* call-seq:
@@ -275,7 +282,7 @@ static VALUE rxml_html_parser_context_close(VALUE self)
 {
   htmlParserCtxtPtr ctxt;
   xmlParserInputPtr xinput;
-  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+  TypedData_Get_Struct(self, htmlParserCtxt, &rxml_html_parser_context_type, ctxt);
 
   while ((xinput = inputPop(ctxt)) != NULL)
   {
@@ -293,7 +300,7 @@ static VALUE rxml_html_parser_context_close(VALUE self)
 static VALUE rxml_html_parser_context_disable_cdata_set(VALUE self, VALUE value)
 {
   htmlParserCtxtPtr ctxt;
-  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+  TypedData_Get_Struct(self, htmlParserCtxt, &rxml_html_parser_context_type, ctxt);
 
   if (ctxt->sax == NULL)
     rb_raise(rb_eRuntimeError, "Sax handler is not yet set");
@@ -320,9 +327,8 @@ static VALUE rxml_html_parser_context_options_set(VALUE self, VALUE options)
 {
   int xml_options = NUM2INT(options);
   htmlParserCtxtPtr ctxt;
-  Check_Type(options, T_FIXNUM);
 
-  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+  TypedData_Get_Struct(self, htmlParserCtxt, &rxml_html_parser_context_type, ctxt);
   htmlCtxtUseOptions(ctxt, xml_options);
 
 #if LIBXML_VERSION >= 20707
@@ -337,10 +343,17 @@ static VALUE rxml_html_parser_context_options_set(VALUE self, VALUE options)
   return self;
 }
 
+static VALUE rxml_html_parser_context_alloc(VALUE klass)
+{
+  xmlParserCtxtPtr ctxt = htmlNewParserCtxt();
+  return TypedData_Wrap_Struct(klass, &rxml_html_parser_context_type, ctxt);
+}
+
 void rxml_init_html_parser_context(void)
 {
   IO_ATTR = ID2SYM(rb_intern("@io"));
   cXMLHtmlParserContext = rb_define_class_under(cXMLHtmlParser, "Context", cXMLParserContext);
+  rb_define_alloc_func(cXMLHtmlParserContext, rxml_html_parser_context_alloc);
 
   rb_define_singleton_method(cXMLHtmlParserContext, "file", rxml_html_parser_context_file, -1);
   rb_define_singleton_method(cXMLHtmlParserContext, "io", rxml_html_parser_context_io, -1);

data/ext/libxml/ruby_xml_html_parser_context.h

@@ -4,6 +4,7 @@
 #define __RXML_HTML_PARSER_CONTEXT__
 
 extern VALUE cXMLHtmlParserContext;
+extern const rb_data_type_t rxml_html_parser_context_type;
 
 void rxml_init_html_parser_context(void);
 

data/ext/libxml/ruby_xml_input_cbg.c

@@ -8,8 +8,38 @@
  * Support for adding custom scheme handlers. */
 
 static ic_scheme *first_scheme = 0;
+static int input_callbacks_registered = 0;
 
-int ic_match(char const *filename)
+static int ic_match(char const *filename);
+static void* ic_open(char const *filename);
+static int ic_read(void *context, char *buffer, int len);
+static int ic_close(void *context);
+
+static void input_callbacks_register_once(void)
+{
+  if (input_callbacks_registered)
+    return;
+
+  xmlRegisterInputCallbacks(ic_match, ic_open, ic_read, ic_close);
+  input_callbacks_registered = 1;
+}
+
+static char *ic_strdup(const char *string)
+{
+  size_t length = strlen(string) + 1;
+  char *copy = ruby_xmalloc(length);
+  memcpy(copy, string, length);
+  return copy;
+}
+
+static void ic_scheme_free(ic_scheme *scheme)
+{
+  rb_gc_unregister_address(&scheme->class);
+  ruby_xfree(scheme->scheme_name);
+  ruby_xfree(scheme);
+}
+
+static int ic_match(char const *filename)
 {
   ic_scheme *scheme;
 
@@ -27,7 +57,7 @@ int ic_match(char const *filename)
   return 0;
 }
 
-void* ic_open(char const *filename)
+static void* ic_open(char const *filename)
 {
   ic_doc_context *ic_doc;
   ic_scheme *scheme;
@@ -38,12 +68,11 @@ void* ic_open(char const *filename)
   {
     if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST scheme->scheme_name, scheme->name_len))
     {
-      ic_doc = (ic_doc_context*) malloc(sizeof(ic_doc_context));
-
       res = rb_funcall(scheme->class, rb_intern("document_query"), 1,
           rb_str_new2(filename));
 
-      ic_doc->buffer = strdup(StringValuePtr(res));
+      ic_doc = ALLOC(ic_doc_context);
+      ic_doc->buffer = ic_strdup(StringValueCStr(res));
 
       ic_doc->bpos = ic_doc->buffer;
       ic_doc->remaining = (int)strlen(ic_doc->buffer);
@@ -54,7 +83,7 @@ void* ic_open(char const *filename)
   return 0;
 }
 
-int ic_read(void *context, char *buffer, int len)
+static int ic_read(void *context, char *buffer, int len)
 {
   ic_doc_context *ic_doc;
   int ret_len;
@@ -75,7 +104,7 @@ int ic_read(void *context, char *buffer, int len)
   return ret_len;
 }
 
-int ic_close(void *context)
+static int ic_close(void *context)
 {
   ruby_xfree(((ic_doc_context*) context)->buffer);
   ruby_xfree(context);
@@ -90,7 +119,7 @@ int ic_close(void *context)
  */
 static VALUE input_callbacks_register_input_callbacks(VALUE self)
 {
-  xmlRegisterInputCallbacks(ic_match, ic_open, ic_read, ic_close);
+  input_callbacks_register_once();
   return (Qtrue);
 }
 
@@ -107,11 +136,14 @@ static VALUE input_callbacks_add_scheme(VALUE self, VALUE scheme_name,
 
   Check_Type(scheme_name, T_STRING);
 
-  scheme = (ic_scheme*) malloc(sizeof(ic_scheme));
+  input_callbacks_register_once();
+
+  scheme = ALLOC(ic_scheme);
   scheme->next_scheme = 0;
-  scheme->scheme_name = strdup(StringValuePtr(scheme_name)); /* TODO alloc, dealloc */
+  scheme->scheme_name = ic_strdup(StringValueCStr(scheme_name));
   scheme->name_len = (int)strlen(scheme->scheme_name);
-  scheme->class = class; /* TODO alloc, dealloc */
+  scheme->class = class;
+  rb_gc_register_address(&scheme->class);
 
   //fprintf( stderr, "registered: %s, %d, %s\n", scheme->scheme_name, scheme->name_len, scheme->class );
 
@@ -150,9 +182,7 @@ static VALUE input_callbacks_remove_scheme(VALUE self, VALUE scheme_name)
   {
     save_scheme = first_scheme->next_scheme;
 
-    ruby_xfree(first_scheme->scheme_name);
-    ruby_xfree(first_scheme);
-
+    ic_scheme_free(first_scheme);
     first_scheme = save_scheme;
     return Qtrue;
   }
@@ -165,9 +195,7 @@ static VALUE input_callbacks_remove_scheme(VALUE self, VALUE scheme_name)
     {
       save_scheme = scheme->next_scheme->next_scheme;
 
-      ruby_xfree(scheme->next_scheme->scheme_name);
-      ruby_xfree(scheme->next_scheme);
-
+      ic_scheme_free(scheme->next_scheme);
       scheme->next_scheme = save_scheme;
       return Qtrue;
     }

data/ext/libxml/ruby_xml_io.c

@@ -19,6 +19,8 @@ int rxml_read_callback(void *context, char *buffer, int len)
     return 0;
 
   size = RSTRING_LEN(string);
+  if (size > (size_t)len)
+    size = (size_t)len;
   memcpy(buffer, StringValuePtr(string), size);
 
   return (int)size;
@@ -30,7 +32,7 @@ int rxml_write_callback(VALUE io, const char *buffer, int len)
     {
         // Could be StringIO
         VALUE written, string;
-        string = rb_external_str_new_with_enc(buffer, (long)strlen(buffer), rb_enc_get(io));
+        string = rb_external_str_new_with_enc(buffer, (long)len, rb_enc_get(io));
         written = rb_funcall(io, WRITE_METHOD, 1, string);
         return NUM2INT(written);
     }

data/ext/libxml/ruby_xml_namespace.c

@@ -5,6 +5,11 @@
 
 VALUE cXMLNamespace;
 
+const rb_data_type_t rxml_namespace_type = {
+  "libxml/namespace",
+  {NULL, NULL, NULL},
+};
+
 /* Document-class: LibXML::XML::Namespace
  *
  * The Namespace class represents an XML namespace.
@@ -26,12 +31,12 @@ VALUE cXMLNamespace;
 
 static VALUE rxml_namespace_alloc(VALUE klass)
 {
-  return Data_Wrap_Struct(klass, NULL, NULL, NULL);
+  return TypedData_Wrap_Struct(klass, &rxml_namespace_type, NULL);
 }
 
 VALUE rxml_namespace_wrap(xmlNsPtr xns)
 {
-  return Data_Wrap_Struct(cXMLNamespace, NULL, NULL, xns);
+  return TypedData_Wrap_Struct(cXMLNamespace, &rxml_namespace_type, xns);
 }
 
 
@@ -50,15 +55,14 @@ static VALUE rxml_namespace_initialize(VALUE self, VALUE node, VALUE prefix,
   xmlChar *xmlPrefix;
   xmlNsPtr xns;
 
-  Check_Type(node, T_DATA);
-  Data_Get_Struct(node, xmlNode, xnode);
+  TypedData_Get_Struct(node, xmlNode, &rxml_node_data_type, xnode);
   xmlResetLastError();
 
   /* Prefix can be null - that means its the default namespace */
   xmlPrefix = NIL_P(prefix) ? NULL : (xmlChar *)StringValuePtr(prefix);
   xns = xmlNewNs(xnode, (xmlChar*) StringValuePtr(href), xmlPrefix);
 
-  DATA_PTR(self) = xns;
+  RTYPEDDATA_DATA(self) = xns;
   return self;
 }
 
@@ -75,7 +79,7 @@ static VALUE rxml_namespace_initialize(VALUE self, VALUE node, VALUE prefix,
 static VALUE rxml_namespace_href_get(VALUE self)
 {
   xmlNsPtr xns;
-  Data_Get_Struct(self, xmlNs, xns);
+  TypedData_Get_Struct(self, xmlNs, &rxml_namespace_type, xns);
   if (xns->href == NULL)
     return Qnil;
   else
@@ -91,7 +95,7 @@ static VALUE rxml_namespace_href_get(VALUE self)
 static VALUE rxml_namespace_node_type(VALUE self)
 {
   xmlNsPtr xns;
-  Data_Get_Struct(self, xmlNs, xns);
+  TypedData_Get_Struct(self, xmlNs, &rxml_namespace_type, xns);
   return INT2NUM(xns->type);
 }
 
@@ -110,7 +114,7 @@ static VALUE rxml_namespace_node_type(VALUE self)
 static VALUE rxml_namespace_prefix_get(VALUE self)
 {
   xmlNsPtr xns;
-  Data_Get_Struct(self, xmlNs, xns);
+  TypedData_Get_Struct(self, xmlNs, &rxml_namespace_type, xns);
   if (xns->prefix == NULL)
     return Qnil;
   else
@@ -132,11 +136,15 @@ static VALUE rxml_namespace_prefix_get(VALUE self)
 static VALUE rxml_namespace_next(VALUE self)
 {
   xmlNsPtr xns;
-  Data_Get_Struct(self, xmlNs, xns);
-  if (xns == NULL || xns->next == NULL)
+  TypedData_Get_Struct(self, xmlNs, &rxml_namespace_type, xns);
+  /* Guard against libxml2's XPath hack where xns->next stores a parent
+     element pointer instead of the next namespace (see xmlXPathNodeSetAddNs
+     in xpath.c).  xmlNs.type and xmlNode.type share the same struct offset,
+     so checking the type is safe even when next points to an xmlNode. */
+  if (xns == NULL || xns->next == NULL || xns->next->type != XML_LOCAL_NAMESPACE)
     return (Qnil);
-  else
-    return rxml_namespace_wrap(xns->next);
+
+  return rxml_namespace_wrap(xns->next);
 }
 
 void rxml_init_namespace(void)

data/ext/libxml/ruby_xml_namespace.h

@@ -4,6 +4,7 @@
 #define __RXML_NAMESPACE__
 
 extern VALUE cXMLNamespace;
+extern const rb_data_type_t rxml_namespace_type;
 
 void rxml_init_namespace(void);
 VALUE rxml_namespace_wrap(xmlNsPtr xns);

data/ext/libxml/ruby_xml_namespaces.c

@@ -5,6 +5,11 @@
 
 VALUE cXMLNamespaces;
 
+static const rb_data_type_t rxml_namespaces_type = {
+  "libxml/namespaces",
+  {NULL, NULL, NULL},
+};
+
 /* Document-class: LibXML::XML::Namespaces
  *
  * The XML::Namespaces class is used to access information about
@@ -38,7 +43,7 @@ VALUE cXMLNamespaces;
 
 static VALUE rxml_namespaces_alloc(VALUE klass)
 {
-  return Data_Wrap_Struct(klass, NULL, NULL, NULL);
+  return TypedData_Wrap_Struct(klass, &rxml_namespaces_type, NULL);
 }
 
 /*
@@ -58,10 +63,9 @@ static VALUE rxml_namespaces_initialize(VALUE self, VALUE node)
 {
   xmlNodePtr xnode;
 
-  Check_Type(node, T_DATA);
-  Data_Get_Struct(node, xmlNode, xnode);
+  TypedData_Get_Struct(node, xmlNode, &rxml_node_data_type, xnode);
 
-  DATA_PTR(self) = xnode;
+  RTYPEDDATA_DATA(self) = xnode;
   return self;
 }
 
@@ -83,7 +87,7 @@ static VALUE rxml_namespaces_definitions(VALUE self)
   xmlNsPtr xns;
   VALUE arr;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
 
   arr = rb_ary_new();
   xns = xnode->nsDef;
@@ -112,24 +116,41 @@ static VALUE rxml_namespaces_definitions(VALUE self)
  *     ..
  *   end
  */
+static VALUE rxml_namespaces_each_yield(VALUE data)
+{
+  xmlNsPtr*nsList = (xmlNsPtr*)data;
+  xmlNsPtr*xns;
+
+  for (xns = nsList; *xns != NULL; xns++)
+  {
+    VALUE ns = rxml_namespace_wrap(*xns);
+    rb_yield(ns);
+  }
+
+  return Qnil;
+}
+
+static VALUE rxml_namespaces_free_list(VALUE data)
+{
+  xmlNsPtr*nsList = (xmlNsPtr*)data;
+  xmlFree(nsList);
+  return Qnil;
+}
+
 static VALUE rxml_namespaces_each(VALUE self)
 {
   xmlNodePtr xnode;
-  xmlNsPtr *nsList, *xns;
+  xmlNsPtr*nsList;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
 
   nsList = xmlGetNsList(xnode->doc, xnode);
 
   if (nsList == NULL)
     return (Qnil);
 
-  for (xns = nsList; *xns != NULL; xns++)
-  {
-    VALUE ns = rxml_namespace_wrap(*xns);
-    rb_yield(ns);
-  }
-  xmlFree(nsList);
+  rb_ensure(rxml_namespaces_each_yield, (VALUE)nsList,
+            rxml_namespaces_free_list, (VALUE)nsList);
 
   return Qnil;
 }
@@ -157,7 +178,7 @@ static VALUE rxml_namespaces_find_by_href(VALUE self, VALUE href)
   xmlNsPtr xns;
 
   Check_Type(href, T_STRING);
-  Data_Get_Struct(self, xmlNode, xnode);
+  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
 
   xns = xmlSearchNsByHref(xnode->doc, xnode, (xmlChar*) StringValuePtr(href));
   if (xns)
@@ -196,7 +217,7 @@ static VALUE rxml_namespaces_find_by_prefix(VALUE self, VALUE prefix)
     xprefix = (xmlChar*) StringValuePtr(prefix);
   }
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
   
   xns = xmlSearchNs(xnode->doc, xnode, xprefix);
   if (xns)
@@ -221,7 +242,7 @@ static VALUE rxml_namespaces_find_by_prefix(VALUE self, VALUE prefix)
 static VALUE rxml_namespaces_namespace_get(VALUE self)
 {
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
 
   if (xnode->ns)
     return rxml_namespace_wrap(xnode->ns);
@@ -253,10 +274,9 @@ static VALUE rxml_namespaces_namespace_set(VALUE self, VALUE ns)
   xmlNodePtr xnode;
   xmlNsPtr xns;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
 
-  Check_Type(ns, T_DATA);
-  Data_Get_Struct(ns, xmlNs, xns);
+  TypedData_Get_Struct(ns, xmlNs, &rxml_namespace_type, xns);
 
   xmlSetNs(xnode, xns);
   return self;
@@ -271,7 +291,7 @@ static VALUE rxml_namespaces_namespace_set(VALUE self, VALUE ns)
 static VALUE rxml_namespaces_node_get(VALUE self)
 {
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  TypedData_Get_Struct(self, xmlNode, &rxml_namespaces_type, xnode);
   return rxml_node_wrap(xnode);
 }
 

data/ext/libxml/ruby_xml_node.c

@@ -8,6 +8,10 @@
 
 VALUE cXMLNode;
 
+#ifndef TYPED_DATA_EMBEDDED
+#define TYPED_DATA_EMBEDDED ((VALUE)1)
+#endif
+
 /* Document-class: LibXML::XML::Node
  *
  * Nodes are the primary objects that make up an XML document.
@@ -26,9 +30,9 @@ VALUE cXMLNode;
  * have a parent and do not belong to a document). In these cases,
  * the bindings manage the memory.  They do this by installing a free
  * function and storing a back pointer to the Ruby object from the xmlnode
- * using the _private member on libxml structures.  When the Ruby object
- * goes out of scope, the underlying libxml structure is freed.  Libxml
- * itself then frees all child node (recursively).
+ * using a pointer-keyed registry (see ruby_xml_registry.c).  When the
+ * Ruby object goes out of scope, the underlying libxml structure is freed.
+ * Libxml itself then frees all child node (recursively).
  *
  * For all other nodes (the vast majority), the bindings create temporary
  * Ruby objects that get freed once they go out of scope. Thus there can be
@@ -46,29 +50,71 @@ VALUE cXMLNode;
  * and are no longer in scope (since if they were the document would not be freed).
  */
 
-static void rxml_node_free(xmlNodePtr xnode)
+static void rxml_node_free(void *data)
 {
+  xmlNodePtr xnode = (xmlNodePtr)data;
+  if (!xnode) return;
+
   /* The ruby object wrapping the xml object no longer exists and this
-     is a standalone node without a document or parent so ruby is 
+     is a standalone node without a document or parent so ruby is
      responsible for freeing the underlying node.*/
   if (xnode->doc == NULL && xnode->parent == NULL)
   {
-    // Remove the back linkage from libxml to Ruby
-    xnode->_private = NULL;
+    rxml_registry_unregister(xnode);
     xmlFreeNode(xnode);
   }
 }
 
+/* Three TypedData types are used for nodes, all sharing rxml_node_data_type
+ * as the parent type so that TypedData_Get_Struct type checks pass for any
+ * variant:
+ *
+ *   rxml_node_data_type       - Default. Marks the owning document to prevent
+ *                               GC from collecting it. No free function since
+ *                               libxml owns the node memory.
+ *
+ *   rxml_node_unmanaged_data_type - No mark, no free. Used for transient nodes
+ *                               whose lifetime is not controlled by Ruby (e.g.
+ *                               nodes returned by xmlTextReaderExpand that are
+ *                               freed on the next reader read call).
+ *
+ *   rxml_node_managed_data_type - Marks the document and frees standalone nodes
+ *                               (no doc, no parent) when the Ruby wrapper is
+ *                               collected. Used for nodes created from Ruby
+ *                               that have not yet been inserted into a document.
+ */
+const rb_data_type_t rxml_node_data_type = {
+  .wrap_struct_name = "LibXML::XML::Node",
+  .function = { .dmark = (RUBY_DATA_FUNC)rxml_node_mark, .dfree = NULL },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+const rb_data_type_t rxml_node_unmanaged_data_type = {
+  .wrap_struct_name = "LibXML::XML::Node (unmanaged)",
+  .function = { .dmark = NULL, .dfree = NULL },
+  .parent = &rxml_node_data_type,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static const rb_data_type_t rxml_node_managed_data_type = {
+  .wrap_struct_name = "LibXML::XML::Node (managed)",
+  .function = { .dmark = (RUBY_DATA_FUNC)rxml_node_mark, .dfree = rxml_node_free },
+  .parent = &rxml_node_data_type,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 void rxml_node_manage(xmlNodePtr xnode, VALUE node)
 {
-  RDATA(node)->dfree = (RUBY_DATA_FUNC)rxml_node_free;
-  xnode->_private = (void*)node;
+  VALUE *type_ptr = (VALUE *)&RTYPEDDATA(node)->type;
+  *type_ptr = (*type_ptr & TYPED_DATA_EMBEDDED) | (VALUE)&rxml_node_managed_data_type;
+  rxml_registry_register(xnode, node);
 }
 
 void rxml_node_unmanage(xmlNodePtr xnode, VALUE node)
 {
-  RDATA(node)->dfree = NULL;
-  xnode->_private = NULL;
+  VALUE *type_ptr = (VALUE *)&RTYPEDDATA(node)->type;
+  *type_ptr = (*type_ptr & TYPED_DATA_EMBEDDED) | (VALUE)&rxml_node_data_type;
+  rxml_registry_unregister(xnode);
 }
 
 xmlNodePtr rxml_node_root(xmlNodePtr xnode)
@@ -87,20 +133,16 @@ void rxml_node_mark(xmlNodePtr xnode)
 {
    if (xnode->doc)
    {
-     if (xnode->doc->_private)
-	 {
-	   VALUE doc = (VALUE)xnode->doc->_private;
-	   rb_gc_mark(doc);
-	 }
+     VALUE doc = rxml_registry_lookup(xnode->doc);
+     if (!NIL_P(doc))
+       rb_gc_mark(doc);
    }
    else if (xnode->parent)
    {
      xmlNodePtr root = rxml_node_root(xnode);
-     if (root->_private)
-     {
-       VALUE node = (VALUE)root->_private;
+     VALUE node = rxml_registry_lookup(root);
+     if (!NIL_P(node))
        rb_gc_mark(node);
-     }
    }
 }
 
@@ -109,13 +151,10 @@ VALUE rxml_node_wrap(xmlNodePtr xnode)
   VALUE result = Qnil;
 
   // Is this node already wrapped?
-  if (xnode->_private)
-  {
-    result = (VALUE)xnode->_private;
-  }
-  else
+  result = rxml_registry_lookup(xnode);
+  if (NIL_P(result))
   {
-    result = Data_Wrap_Struct(cXMLNode, rxml_node_mark, NULL, xnode);
+    result = TypedData_Wrap_Struct(cXMLNode, &rxml_node_data_type, xnode);
   }
 
   if (!xnode->doc && !xnode->parent)
@@ -128,13 +167,13 @@ VALUE rxml_node_wrap(xmlNodePtr xnode)
 static VALUE rxml_node_alloc(VALUE klass)
 {
   // This node was created from Ruby so we are responsible for freeing it not libxml
-  return Data_Wrap_Struct(klass, rxml_node_mark, rxml_node_free, NULL);
+  return TypedData_Wrap_Struct(klass, &rxml_node_data_type, NULL);
 }
 
 static xmlNodePtr rxml_get_xnode(VALUE node)
 {
    xmlNodePtr result;
-   Data_Get_Struct(node, xmlNode, result);
+   TypedData_Get_Struct(node, xmlNode, &rxml_node_data_type, result);
 
    if (!result)
     rb_raise(rb_eRuntimeError, "This node has already been freed.");
@@ -283,7 +322,7 @@ static VALUE rxml_node_initialize(int argc, VALUE *argv, VALUE self)
   name = rb_obj_as_string(name);
 
   if (!NIL_P(ns))
-    Data_Get_Struct(ns, xmlNs, xns);
+    TypedData_Get_Struct(ns, xmlNs, &rxml_namespace_type, xns);
 
   xnode = xmlNewNode(xns, (xmlChar*) StringValuePtr(name));
 
@@ -291,7 +330,7 @@ static VALUE rxml_node_initialize(int argc, VALUE *argv, VALUE self)
     rxml_raise(xmlGetLastError());
 
   // Link the ruby wrapper to the underlying libxml node
-  RDATA(self)->data = xnode;
+  RTYPEDDATA_DATA(self) = xnode;
 
   // Ruby is in charge of managing this node's memory
   rxml_node_manage(xnode, self);
@@ -329,7 +368,7 @@ static VALUE rxml_node_modify_dom(VALUE self, VALUE target,
 
   /* Assume the target was freed, we need to fix up the ruby object to point to the
      newly returned node. */
-  RDATA(target)->data = xresult;
+  RTYPEDDATA_DATA(target) = xresult;
 
   return target;
 }
@@ -533,7 +572,7 @@ static VALUE rxml_node_doc(VALUE self)
   if (xdoc == NULL)
     return (Qnil);
 
-  return (VALUE)xdoc->_private;
+  return rxml_registry_lookup(xdoc);
 }
 
 /*

data/ext/libxml/ruby_xml_node.h

@@ -4,6 +4,8 @@
 #define __RXML_NODE__
 
 extern VALUE cXMLNode;
+extern const rb_data_type_t rxml_node_data_type;
+extern const rb_data_type_t rxml_node_unmanaged_data_type;
 
 void rxml_init_node(void);
 void rxml_node_mark(xmlNodePtr xnode);

data/ext/libxml/ruby_xml_parser.c

@@ -64,7 +64,7 @@ static VALUE rxml_parser_parse(VALUE self)
   xmlParserCtxtPtr ctxt;
   VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
   
-  Data_Get_Struct(context, xmlParserCtxt, ctxt);
+  TypedData_Get_Struct(context, xmlParserCtxt, &rxml_parser_context_type, ctxt);
 
   if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery)
   {