libxml-ruby 5.0.5 → 6.0.0

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

@@ -1,13 +1,15 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_NODE__
-#define __RXML_NODE__
-
-extern VALUE cXMLNode;
-
-void rxml_init_node(void);
-void rxml_node_mark(xmlNodePtr xnode);
-VALUE rxml_node_wrap(xmlNodePtr xnode);
-void rxml_node_manage(xmlNodePtr xnode, VALUE node);
-void rxml_node_unmanage(xmlNodePtr xnode, VALUE node);
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_NODE__
+#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);
+VALUE rxml_node_wrap(xmlNodePtr xnode);
+void rxml_node_manage(xmlNodePtr xnode, VALUE node);
+void rxml_node_unmanage(xmlNodePtr xnode, VALUE node);
+#endif

data/ext/libxml/ruby_xml_parser.c

@@ -1,91 +1,91 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include <stdarg.h>
-#include "ruby_libxml.h"
-
-/*
- * Document-class: LibXML::XML::Parser
- *
- * The XML::Parser provides a tree based API for processing
- * xml documents, in contract to XML::Reader's stream
- * based api and XML::SaxParser callback based API.
- *
- * As a result, parsing a document creates an in-memory document object
- * that consist of any number of XML::Node instances.  This is simple
- * and powerful model, but has the major limitation that the size of
- * the document that can be processed is limited by the amount of
- * memory available.  In such cases, it is better to use the XML::Reader.
- *
- * Using the parser is simple:
- *
- *   parser = XML::Parser.file('my_file')
- *   doc = parser.parse
- *
- * You can also parse documents (see XML::Parser.document), 
- * strings (see XML::Parser.string) and io objects (see
- * XML::Parser.io).
- */
-
-VALUE cXMLParser;
-static ID CONTEXT_ATTR;
-
-/*
- * call-seq:
- *    parser.initialize(context) -> XML::Parser
- *
- * Creates a new XML::Parser from the specified 
- * XML::Parser::Context.
- */
-static VALUE rxml_parser_initialize(int argc, VALUE *argv, VALUE self)
-{
-  VALUE context = Qnil;
-
-  rb_scan_args(argc, argv, "01", &context);
-
-  if (context == Qnil)
-  {
-    rb_raise(rb_eArgError, "An instance of a XML::Parser::Context must be passed to XML::Parser.new");
-  }
-
-  rb_ivar_set(self, CONTEXT_ATTR, context);
-  return self;
-}
-
-/*
- * call-seq:
- *    parser.parse -> XML::Document
- *
- * Parse the input XML and create an XML::Document with
- * it's content. If an error occurs, XML::Parser::ParseError
- * is thrown.
- */
-static VALUE rxml_parser_parse(VALUE self)
-{
-  xmlParserCtxtPtr ctxt;
-  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
-  
-  Data_Get_Struct(context, xmlParserCtxt, ctxt);
-
-  if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery)
-  {
-    rxml_raise(&ctxt->lastError);
-  }
-
-  rb_funcall(context, rb_intern("close"), 0);
-
-  return rxml_document_wrap(ctxt->myDoc);
-}
-
-void rxml_init_parser(void)
-{
-  cXMLParser = rb_define_class_under(mXML, "Parser", rb_cObject);
-
-  /* Atributes */
-  CONTEXT_ATTR = rb_intern("@context");
-  rb_define_attr(cXMLParser, "input", 1, 0);
-  rb_define_attr(cXMLParser, "context", 1, 0);
-
-  /* Instance Methods */
-  rb_define_method(cXMLParser, "initialize", rxml_parser_initialize, -1);
-  rb_define_method(cXMLParser, "parse", rxml_parser_parse, 0);
-}
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include <stdarg.h>
+#include "ruby_libxml.h"
+
+/*
+ * Document-class: LibXML::XML::Parser
+ *
+ * The XML::Parser provides a tree based API for processing
+ * xml documents, in contract to XML::Reader's stream
+ * based api and XML::SaxParser callback based API.
+ *
+ * As a result, parsing a document creates an in-memory document object
+ * that consist of any number of XML::Node instances.  This is simple
+ * and powerful model, but has the major limitation that the size of
+ * the document that can be processed is limited by the amount of
+ * memory available.  In such cases, it is better to use the XML::Reader.
+ *
+ * Using the parser is simple:
+ *
+ *   parser = XML::Parser.file('my_file')
+ *   doc = parser.parse
+ *
+ * You can also parse documents (see XML::Parser.document), 
+ * strings (see XML::Parser.string) and io objects (see
+ * XML::Parser.io).
+ */
+
+VALUE cXMLParser;
+static ID CONTEXT_ATTR;
+
+/*
+ * call-seq:
+ *    parser.initialize(context) -> XML::Parser
+ *
+ * Creates a new XML::Parser from the specified 
+ * XML::Parser::Context.
+ */
+static VALUE rxml_parser_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE context = Qnil;
+
+  rb_scan_args(argc, argv, "01", &context);
+
+  if (context == Qnil)
+  {
+    rb_raise(rb_eArgError, "An instance of a XML::Parser::Context must be passed to XML::Parser.new");
+  }
+
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    parser.parse -> XML::Document
+ *
+ * Parse the input XML and create an XML::Document with
+ * it's content. If an error occurs, XML::Parser::ParseError
+ * is thrown.
+ */
+static VALUE rxml_parser_parse(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  
+  TypedData_Get_Struct(context, xmlParserCtxt, &rxml_parser_context_type, ctxt);
+
+  if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery)
+  {
+    rxml_raise(&ctxt->lastError);
+  }
+
+  rb_funcall(context, rb_intern("close"), 0);
+
+  return rxml_document_wrap(ctxt->myDoc);
+}
+
+void rxml_init_parser(void)
+{
+  cXMLParser = rb_define_class_under(mXML, "Parser", rb_cObject);
+
+  /* Atributes */
+  CONTEXT_ATTR = rb_intern("@context");
+  rb_define_attr(cXMLParser, "input", 1, 0);
+  rb_define_attr(cXMLParser, "context", 1, 0);
+
+  /* Instance Methods */
+  rb_define_method(cXMLParser, "initialize", rxml_parser_initialize, -1);
+  rb_define_method(cXMLParser, "parse", rxml_parser_parse, 0);
+}