Update libxml-ruby to no longer use the _private field in XML objects. Instead maintain a separate registry that maps XML objects to Ruby values.

Author: cfis

ext/libxml/libxml.c

@@ -46,6 +46,7 @@ void Init_libxml_ruby(void)
   mLibXML = rb_define_module("LibXML");
 
   rxml_init_memory();
+  rxml_init_registry();
   rxml_init_xml();
   rxml_init_io();
   rxml_init_error();

ext/libxml/ruby_libxml.h

@@ -37,6 +37,7 @@
 #include "ruby_xml_dtd.h"
 #include "ruby_xml_schema.h"
 #include "ruby_xml_relaxng.h"
+#include "ruby_xml_registry.h"
 
 extern VALUE mLibXML;
 

ext/libxml/ruby_xml_attr.c

@@ -140,7 +140,7 @@ static VALUE rxml_attr_doc_get(VALUE self)
   if (xattr->doc == NULL)
     return Qnil;
   else
-    return rxml_document_wrap(xattr->doc);
+    return rxml_registry_lookup(xattr->doc);
 }
 
 /*

ext/libxml/ruby_xml_attr_decl.c

@@ -43,7 +43,7 @@ static VALUE rxml_attr_decl_doc_get(VALUE self)
   if (xattr->doc == NULL)
     return Qnil;
   else
-    return rxml_document_wrap(xattr->doc);
+    return rxml_registry_lookup(xattr->doc);
 }
 
 

ext/libxml/ruby_xml_document.c

@@ -64,7 +64,7 @@ void rxml_document_free(void* data)
 {
   xmlDocPtr xdoc = (xmlDocPtr)data;
   if (!xdoc) return;
-  xdoc->_private = NULL;
+  rxml_registry_unregister(xdoc);
   xmlFreeDoc(xdoc);
 }
 
@@ -78,15 +78,12 @@ VALUE rxml_document_wrap(xmlDocPtr xdoc)
 {
   VALUE result = Qnil;
 
-  // Is this node is already wrapped?
-  if (xdoc->_private != NULL)
-  {
-    result = (VALUE)xdoc->_private;
-  }
-  else
+  // Is this document already wrapped?
+  result = rxml_registry_lookup(xdoc);
+  if (NIL_P(result))
   {
     result = TypedData_Wrap_Struct(cXMLDocument, &rxml_document_data_type, xdoc);
-    xdoc->_private = (void*)result;
+    rxml_registry_register(xdoc, result);
   }
 
   return result;
@@ -133,7 +130,7 @@ static VALUE rxml_document_initialize(int argc, VALUE *argv, VALUE self)
 
   // Link the ruby object to the document and the document to the ruby object
   RTYPEDDATA_DATA(self) = xdoc;
-  xdoc->_private = (void*)self;
+  rxml_registry_register(xdoc, self);
 
   return self;
 }

ext/libxml/ruby_xml_dtd.c

@@ -47,8 +47,9 @@ static void rxml_dtd_mark(void* data)
   xmlDtdPtr xdtd = (xmlDtdPtr)data;
   if (xdtd && xdtd->doc)
   {
-      VALUE doc = (VALUE)xdtd->doc->_private;
-      rb_gc_mark(doc);
+      VALUE doc = rxml_registry_lookup(xdtd->doc);
+      if (!NIL_P(doc))
+        rb_gc_mark(doc);
   }
 }
 

ext/libxml/ruby_xml_node.c

@@ -30,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
@@ -60,8 +60,7 @@ static void rxml_node_free(void *data)
      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);
   }
 }
@@ -108,14 +107,14 @@ void rxml_node_manage(xmlNodePtr xnode, VALUE node)
 {
   VALUE *type_ptr = (VALUE *)&RTYPEDDATA(node)->type;
   *type_ptr = (*type_ptr & TYPED_DATA_EMBEDDED) | (VALUE)&rxml_node_managed_data_type;
-  xnode->_private = (void*)node;
+  rxml_registry_register(xnode, node);
 }
 
 void rxml_node_unmanage(xmlNodePtr xnode, VALUE node)
 {
   VALUE *type_ptr = (VALUE *)&RTYPEDDATA(node)->type;
   *type_ptr = (*type_ptr & TYPED_DATA_EMBEDDED) | (VALUE)&rxml_node_data_type;
-  xnode->_private = NULL;
+  rxml_registry_unregister(xnode);
 }
 
 xmlNodePtr rxml_node_root(xmlNodePtr xnode)
@@ -134,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);
-     }
    }
 }
 
@@ -156,11 +151,8 @@ 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 = TypedData_Wrap_Struct(cXMLNode, &rxml_node_data_type, xnode);
   }
@@ -580,7 +572,7 @@ static VALUE rxml_node_doc(VALUE self)
   if (xdoc == NULL)
     return (Qnil);
 
-  return (VALUE)xdoc->_private;
+  return rxml_registry_lookup(xdoc);
 }
 
 /*

ext/libxml/ruby_xml_reader.c

@@ -70,10 +70,11 @@ static void rxml_reader_mark(void* data)
 {
   xmlTextReaderPtr xreader = (xmlTextReaderPtr)data;
   xmlDocPtr xdoc = xmlTextReaderCurrentDoc(xreader);
-  if (xdoc && xdoc->_private)
+  if (xdoc)
   {
-    VALUE doc = (VALUE)xdoc->_private;
-    rb_gc_mark(doc);
+    VALUE doc = rxml_registry_lookup(xdoc);
+    if (!NIL_P(doc))
+      rb_gc_mark(doc);
   }
 }
 

ext/libxml/ruby_xml_registry.c

@@ -0,0 +1,31 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_registry.h"
+
+#include <ruby/st.h>
+
+static st_table *rxml_registry;
+
+void rxml_init_registry(void)
+{
+  rxml_registry = st_init_numtable();
+}
+
+void rxml_registry_register(void *ptr, VALUE obj)
+{
+  st_insert(rxml_registry, (st_data_t)ptr, (st_data_t)obj);
+}
+
+void rxml_registry_unregister(void *ptr)
+{
+  st_delete(rxml_registry, (st_data_t *)&ptr, NULL);
+}
+
+VALUE rxml_registry_lookup(void *ptr)
+{
+  st_data_t val;
+  if (st_lookup(rxml_registry, (st_data_t)ptr, &val))
+    return (VALUE)val;
+  return Qnil;
+}

ext/libxml/ruby_xml_registry.h

@@ -0,0 +1,22 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_REGISTRY__
+#define __RXML_REGISTRY__
+
+/* Pointer-to-VALUE registry for mapping C structs (xmlDocPtr, xmlNodePtr,
+   etc.) back to their Ruby wrappers.
+
+   The registry is a global st_table keyed by C pointer address.  It is NOT a
+   GC root -- entries do not prevent garbage collection.  Objects stay alive
+   through the normal mark chains (mark functions look up the registry instead
+   of reading _private).
+
+   Registered pointers MUST be unregistered before the underlying C struct is
+   freed, typically in the wrapper's dfree function. */
+
+void  rxml_init_registry(void);
+void  rxml_registry_register(void *ptr, VALUE obj);
+void  rxml_registry_unregister(void *ptr);
+VALUE rxml_registry_lookup(void *ptr);   /* Qnil on miss */
+
+#endif