libxml-ruby 0.3.8 → 0.3.8.2

data/ext/xml/ruby_xml_node.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_node.c,v 1.3 2006/04/12 12:08:39 roscopeco Exp $ */
+/* $Id: ruby_xml_node.c,v 1.9 2006/11/20 01:22:07 roscopeco Exp $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -10,6 +10,15 @@ VALUE eXMLNodeSetNamespace;
 VALUE eXMLNodeFailedModify;
 VALUE eXMLNodeUnknownType;
 
+static VALUE
+check_string_or_symbol( VALUE val ) {
+  if( TYPE(val) != T_STRING && TYPE(val) != T_SYMBOL ) {
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected String or Symbol)", 
+    rb_obj_classname(val) );
+  }
+  return rb_obj_as_string( val );
+}
+
 /*
  * call-seq:
  *    node.attribute? => (true|false)
@@ -122,7 +131,7 @@ ruby_xml_node_comment_q(VALUE self) {
 
 /*
  * call-seq:
- *    node << ("string" | node)
+ *    node << ("string" | node) => node
  * 
  * Add the specified string or XML::Node to this node's
  * content.
@@ -134,17 +143,18 @@ ruby_xml_node_content_add(VALUE self, VALUE obj) {
 
   Data_Get_Struct(self, ruby_xml_node, node);
   if (rb_obj_is_kind_of(obj, cXMLNode)) {
-    return(ruby_xml_node_child_set(self, obj));
+    ruby_xml_node_child_set(self, obj);
+    return(self);
   } else if (TYPE(obj) == T_STRING) {
     xmlNodeAddContent(node->node, (xmlChar*)StringValuePtr(obj));
-    return(obj);
+    return(self);
   } else {
     str = rb_obj_as_string(obj);
     if (NIL_P(str) || TYPE(str) != T_STRING)
       rb_raise(rb_eTypeError, "invalid argument: must be string or XML::Node");
 
     xmlNodeAddContent(node->node, (xmlChar*)StringValuePtr(str));
-    return(obj);
+    return(self);
   }
 }
 
@@ -206,11 +216,6 @@ ruby_xml_node_content_stripped_get(VALUE self) {
     return(rb_str_new2((const char*)xmlNodeGetContent(rxn->node)));
 }
 
-////////////////////////////////////////////////////
-// TODO This whole child thing seems to work in some odd ways.
-//      Try setting child= to a node with multiple children,
-//      then get it back through child= .
-      
 /*
  * call-seq:
  *    node.child => node
@@ -252,7 +257,7 @@ ruby_xml_node_child_get(VALUE self) {
   if (tmp == NULL)
     return(Qnil);
   else
-    return(ruby_xml_node_new2(cXMLNode, node->xd, tmp));
+    return(ruby_xml_node_new_ptr(cXMLNode, node->xd, tmp));
 }
 
 
@@ -300,6 +305,7 @@ ruby_xml_node_child_q(VALUE self) {
 }
 
 
+// TODO Fixes below should be applied to sibling, prev, etc ?
 /*
  * call-seq:
  *    node.child = node
@@ -309,20 +315,45 @@ ruby_xml_node_child_q(VALUE self) {
 VALUE
 ruby_xml_node_child_set(VALUE self, VALUE rnode) {
   ruby_xml_node *cnode, *pnode;
-  xmlNodePtr ret;
+  xmlNodePtr chld, ret;
+  ruby_xml_document *pdoc, *cdoc;
+  int ptr;
 
   if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
     rb_raise(rb_eTypeError, "Must pass an XML::Node object");
 
   Data_Get_Struct(self,  ruby_xml_node, pnode);
   Data_Get_Struct(rnode, ruby_xml_node, cnode);
-
-  ret = xmlAddChild(pnode->node, cnode->node);
+  
+  chld = cnode->node;
+  
+  // Only copy if both nodes are in documents, which are different.
+  if (pnode->xd && pnode->xd != Qnil) {
+    Data_Get_Struct(pnode->xd, ruby_xml_document, pdoc);
+    if (cnode->xd && cnode->xd != Qnil) {
+      Data_Get_Struct(cnode->xd, ruby_xml_document, cdoc);
+      if (cdoc->doc != pdoc->doc) {
+        chld = xmlDocCopyNode(chld, pdoc->doc, 1);
+        chld->_private = 0;
+        ptr = 1;
+      }
+    } else {
+      chld = xmlDocCopyNode(chld, pdoc->doc, 1);
+      chld->_private = 0;
+      ptr = 1;
+    }
+  } else {
+    chld->doc = NULL;
+  }
+  
+  ret = xmlAddChild(pnode->node, chld);
   if (ret == NULL)
     rb_raise(eXMLNodeFailedModify, "unable to add a child to the document");
+    
+  cnode->node = ret;
+  cnode->xd = pnode->xd;
 
-  ruby_xml_node_set_ptr(rnode, 1);
-  return(ruby_xml_node_new2(cXMLNode, pnode->xd, ret));
+  return(rnode);
 }
 
 ////////////////////////////////////////////////
@@ -342,6 +373,9 @@ ruby_xml_node_doc(VALUE self) {
   VALUE docobj;
 
   Data_Get_Struct(self, ruby_xml_node, rxn);
+  
+  if (rxn->xd)
+    return(rxn->xd);
 
   switch (rxn->node->type) {
   case XML_DOCUMENT_NODE:
@@ -634,18 +668,18 @@ VALUE
 ruby_xml_node_find_first(int argc, VALUE *argv, VALUE self) {
   VALUE ns = ruby_xml_node_find(argc, argv, self);
   ruby_xml_node_set *rxnset;
+  VALUE nodeobj;
 
   Data_Get_Struct(ns, ruby_xml_node_set, rxnset);
   if (rxnset->node_set == NULL || rxnset->node_set->nodeNr < 1)
     return(Qnil);
 
-  VALUE nodeobj;
   switch(rxnset->node_set->nodeTab[0]->type) {
     case XML_ATTRIBUTE_NODE:
       nodeobj = ruby_xml_attr_new2(cXMLAttr, rxnset->xd, (xmlAttrPtr)rxnset->node_set->nodeTab[0]);
       break;
     default:
-      nodeobj = ruby_xml_node_new2(cXMLNode, rxnset->xd, rxnset->node_set->nodeTab[0]);
+      nodeobj = ruby_xml_node_new_ptr(cXMLNode, rxnset->xd, rxnset->node_set->nodeTab[0]);
   }
 
   return(nodeobj);
@@ -670,12 +704,19 @@ ruby_xml_node_fragment_q(VALUE self) {
 
 
 void ruby_xml_node_free(ruby_xml_node *rxn) {
-  if (rxn->node != NULL && !rxn->is_ptr) {
-    xmlUnlinkNode(rxn->node);
-    xmlFreeNode(rxn->node);
-    rxn->node = NULL;
+  if (rxn->node != NULL &&            // got a node?
+      rxn->node->parent == NULL &&    // unparented (otherwise, it gets freed with parent)
+      rxn->node->doc == NULL) {       // No document? (otherwise, freed with doc)
+    if ((int)rxn->node->_private <= 1) {
+      // is null or last reference, 
+      xmlFreeNode(rxn->node);  
+    } else {
+      // other pointers remain
+      rxn->node->_private--;    
+    }    
   }
 
+  rxn->node = NULL;
   free(rxn);
 }
 
@@ -718,14 +759,16 @@ ruby_xml_node_html_doc_q(VALUE self) {
 /*
  * call-seq:
  *    XML::Node.new(name, content = nil) => node
+ *    XML::Node.new_element(name, content = nil) => node
  * 
- * Create a new node with the specified name, optionally setting
+ * Create a new element node with the specified name, optionally setting
  * the node's content.
  */
 VALUE
 ruby_xml_node_initialize(int argc, VALUE *argv, VALUE class) {
   ruby_xml_node *rxn;
   VALUE name, node, str;
+  xmlNodePtr newxn;
 
   str = Qnil;
 
@@ -746,11 +789,13 @@ ruby_xml_node_initialize(int argc, VALUE *argv, VALUE class) {
      * the object.  Sneaky, but effective.  Probably should use a goto
      * instead. */
   case 1:
-    name = argv[0];
-    Check_Type(name, T_STRING);
-    node = ruby_xml_node_new(class, NULL);
+    name = check_string_or_symbol( argv[0] );
+    newxn = xmlNewNode(NULL, (xmlChar*)StringValuePtr(name));
+    node = ruby_xml_node_new(class, newxn);
+    
     Data_Get_Struct(node, ruby_xml_node, rxn);
-    rxn->node = xmlNewNode(NULL, (xmlChar*)StringValuePtr(name));
+
+    /* TODO How would this happen? Shouldn't we raise on it anyway? */    
     if (rxn->node == NULL)
       return(Qnil);
 
@@ -766,7 +811,86 @@ ruby_xml_node_initialize(int argc, VALUE *argv, VALUE class) {
   return(node);
 }
 
+/*
+ * call-seq:
+ *    XML::Node.new_cdata(content = nil) => node
+ * 
+ * Create a new #CDATA node, optionally setting
+ * the node's content.
+ */
+VALUE
+ruby_xml_node_cdata_initialize(int argc, VALUE *argv, VALUE class) {
+  xmlNode *xnode;
+  VALUE node, str;
+
+  str = Qnil;
+
+  switch(argc) {
+  case 1:
+    str = argv[0];
+    Check_Type(str, T_STRING);
+    if (!NIL_P(str)) {
+      xnode = xmlNewCDataBlock(NULL, (xmlChar*)StringValuePtr(str), xmlStrlen((xmlChar*)StringValuePtr(str)));
+    } else {
+      xnode = xmlNewCDataBlock(NULL, NULL , 0);
+    }
 
+    if (xnode == NULL)
+      return(Qnil);
+      
+    node = ruby_xml_node_new(class, xnode);
+
+    break;
+
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (1)");
+  }
+
+  return(node);
+}
+
+
+/*
+ * call-seq:
+ *    XML::Node.new_comment(content = nil) => node
+ * 
+ * Create a new comment node, optionally setting
+ * the node's content.
+ * 
+ */
+VALUE
+ruby_xml_node_comment_initialize(int argc, VALUE *argv, VALUE class) {
+  xmlNode *xnode;
+  VALUE node, str;
+
+  str = Qnil;
+
+  switch(argc) {
+  case 1:
+    str = argv[0];
+    Check_Type(str, T_STRING);
+// TODO  xmlNewComment wrongly? adds \n before and after the comment
+    if (!NIL_P(str)) {
+      xnode = xmlNewComment((xmlChar*)StringValuePtr(str));
+    } else {
+      xnode = xmlNewComment(NULL);
+    }
+
+    if (xnode == NULL)
+      return(Qnil);
+
+    node = ruby_xml_node_new(class, xnode);
+
+    break;
+
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (1)");
+  }
+
+  return(node);
+}
+
+ 
 /*
  * call-seq:
  *    node.lang => "string"
@@ -850,7 +974,7 @@ ruby_xml_node_last_get(VALUE self) {
   if (node == NULL)
     return(Qnil);
   else
-    return(ruby_xml_node_new2(cXMLNode, rxn->xd, node));
+    return(ruby_xml_node_new_ptr(cXMLNode, rxn->xd, node));
 }
 
 
@@ -1213,33 +1337,85 @@ ruby_xml_node_namespace_q(VALUE self) {
     return(Qfalse);
 }
 
-
+/* TODO new_ptr and new3 are obsolete, should be consolidated */
 VALUE
 ruby_xml_node_new(VALUE class, xmlNodePtr node) {
-  ruby_xml_node *rxn;
+  return ruby_xml_node_new_ptr(class, Qnil, node);    
+}
 
-  rxn = ALLOC(ruby_xml_node);
-  rxn->is_ptr = 0;
-  rxn->node = node;
-  rxn->xd = Qnil;
-  return(Data_Wrap_Struct(class, ruby_xml_node_mark,
-			  ruby_xml_node_free, rxn));
+
+VALUE
+ruby_xml_node_new_ptr(VALUE class, VALUE xd, xmlNodePtr node) {
+  return ruby_xml_node_new3(class, xd, node, 1);
 }
 
 
+/* TODO ptr arg is obsolete, should be removed */
+
+/* Here's how this works:
+ * 
+ *    All nodes are 'pointer' nodes, but no node owns the xmlNode 
+ *    structure they're associated with. Instead, we maintain a 
+ *    count of the number of VALUEs out there wrapping a given
+ *    node, in the nodes _private member. When we wrap a node,
+ *    this is incremented.
+ * 
+ *    In ruby_xml_node_free , the count is checked and if it's 
+ *    either NULL or 1 (indicating non-wrapped, or that this is
+ *    the last reference) then the node is freed along with the
+ *    ruby_xml_node that points to it. Otherwise, just the
+ *    ruby struct is freed and the node is retained.
+ * 
+ *    This fixes a problem with the old setup whereby ruby_xml_nodes
+ *    with is_ptr = 1 could remain after the node they were pointing
+ *    to had been collected. It also helps to ensure we're 
+ *    threadsafe (according to the libxml2 threadsafety rules).
+ * 
+ *    N.B. The XD document pointer is very important - when time 
+ *    comes to free a node, we *must* not free nodes that belong
+ *    to a document, or have a parent - they will be freed either
+ *    with the document or with the parent (xmlFreeNode calls
+ *    xmlFreeNodeList on the kids). You need to make sure that 
+ *    you keep the XD up to date with the node->doc.
+ * 
+ *    TODO there should be a func that does that.
+ * 
+ *    N.B. You can't do this any more:
+ * 
+ *        node = ruby_xml_node_new3(class, NULL);
+ *        Data_Get_Struct(node, ruby_xml_node, rxn);
+ *        rxn->node = someXmlNode;
+ * 
+ *    You *must* pass in the node when your making the new rxn.
+ *    This saves confusion about who owns what node, and lets the
+ *    refcounts stay consistent.
+ */
 VALUE
-ruby_xml_node_new2(VALUE class, VALUE xd, xmlNodePtr node) {
+ruby_xml_node_new3(VALUE class, VALUE xd, xmlNodePtr node, int ptr) {
   ruby_xml_node *rxn;
-
   rxn = ALLOC(ruby_xml_node);
-  rxn->is_ptr = 1;
+
   rxn->node = node;
-  if (NIL_P(xd))
+  if (node->_private) {
+    node->_private++;            
+  } else {
+    node->_private = (void*)1;
+  }
+    
+  if (NIL_P(xd)) {
     rxn->xd = Qnil;
-  else
+    rxn->node->doc = NULL;
+  } else {
+    /* Have to set node->doc too so we don't doublefree this node */
+    ruby_xml_document *xdoc;
+    Data_Get_Struct(xd, ruby_xml_document, xdoc);
+      
     rxn->xd = xd;
+    rxn->node->doc = xdoc->doc;
+  }
+
   return(Data_Wrap_Struct(class, ruby_xml_node_mark,
-			  ruby_xml_node_free, rxn));
+                         ruby_xml_node_free, rxn));
 }
 
 
@@ -1280,10 +1456,11 @@ ruby_xml_node_next_get(VALUE self) {
     break;
   }
 
-  if (node == NULL)
+  if (node == NULL) {
     return(Qnil);
-  else
-    return(ruby_xml_node_new2(cXMLNode, rxn->xd, node));
+  } else {
+    return(ruby_xml_node_new_ptr(cXMLNode, rxn->xd, node));
+  }
 }
 
 
@@ -1331,6 +1508,31 @@ ruby_xml_node_next_q(VALUE self) {
 }
 
 
+/*
+ * call-seq:
+ *    node.next = node
+ * 
+ * Insert the specified node as this node's next sibling.
+ */
+VALUE
+ruby_xml_node_next_set(VALUE self, VALUE rnode) {
+  ruby_xml_node *cnode, *pnode;
+  xmlNodePtr ret;
+
+  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "Must pass an XML::Node object");
+
+  Data_Get_Struct(self,  ruby_xml_node, pnode);
+  Data_Get_Struct(rnode, ruby_xml_node, cnode);
+
+  ret = xmlAddNextSibling(pnode->node, cnode->node);
+  if (ret == NULL)
+    rb_raise(eXMLNodeFailedModify, "unable to add a sibling to the document");
+
+  return(ruby_xml_node_new_ptr(cXMLNode, pnode->xd, ret));
+}
+
+
 /*
  * call-seq:
  *    node.notation? => (true|false)
@@ -1440,7 +1642,7 @@ ruby_xml_node_parent_get(VALUE self) {
   if (node == NULL)
     return(Qnil);
   else
-    return(ruby_xml_node_new2(cXMLNode, rxn->xd, node));
+    return(ruby_xml_node_new_ptr(cXMLNode, rxn->xd, node));
 }
 
 
@@ -1562,18 +1764,18 @@ ruby_xml_node_prev_get(VALUE self) {
   case XML_ATTRIBUTE_NODE:
     {
       xmlAttrPtr attr = (xmlAttrPtr) rxn->node;
-      node = (xmlNodePtr) attr->next;
+      node = (xmlNodePtr) attr->prev;
     }
     break;
   default:
-    node = rxn->node->next;
+    node = rxn->node->prev;
     break;
   }
 
   if (node == NULL)
     return(Qnil);
   else
-    return(ruby_xml_node_new2(cXMLNode, rxn->xd, node));
+    return(ruby_xml_node_new_ptr(cXMLNode, rxn->xd, node));
 }
 
 
@@ -1602,11 +1804,11 @@ ruby_xml_node_prev_q(VALUE self) {
   case XML_ATTRIBUTE_NODE:
     {
       xmlAttrPtr attr = (xmlAttrPtr) rxn->node;
-      node = (xmlNodePtr) attr->next;
+      node = (xmlNodePtr) attr->prev;
     }
     break;
   default:
-    node = rxn->node->next;
+    node = rxn->node->prev;
     break;
   }
 
@@ -1617,6 +1819,31 @@ ruby_xml_node_prev_q(VALUE self) {
 }
 
 
+/*
+ * call-seq:
+ *    node.prev = node
+ * 
+ * Insert the specified node as this node's previous sibling.
+ */
+VALUE
+ruby_xml_node_prev_set(VALUE self, VALUE rnode) {
+  ruby_xml_node *cnode, *pnode;
+  xmlNodePtr ret;
+
+  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "Must pass an XML::Node object");
+
+  Data_Get_Struct(self,  ruby_xml_node, pnode);
+  Data_Get_Struct(rnode, ruby_xml_node, cnode);
+
+  ret = xmlAddPrevSibling(pnode->node, cnode->node);
+  if (ret == NULL)
+    rb_raise(eXMLNodeFailedModify, "unable to add a sibling to the document");
+
+  return(ruby_xml_node_new_ptr(cXMLNode, pnode->xd, ret));
+}
+
+
 /*
  * call-seq:
  *    node.property("name") => "string"
@@ -1630,8 +1857,8 @@ ruby_xml_node_property_get(VALUE self, VALUE prop) {
   xmlChar *p;
   VALUE r;
   
-  Check_Type(prop, T_STRING);
-
+  prop = check_string_or_symbol( prop );
+  
   Data_Get_Struct(self, ruby_xml_node, rxn);
   p = xmlGetProp(rxn->node, (xmlChar*)StringValuePtr(prop));
 
@@ -1655,12 +1882,10 @@ ruby_xml_node_property_get(VALUE self, VALUE prop) {
 VALUE
 ruby_xml_node_property_set(VALUE self, VALUE key, VALUE val) {
   ruby_xml_node *node;
-  ruby_xml_attr *rxa;
   xmlAttrPtr attr;
-  VALUE rattr;
 
-  Data_Get_Struct(self, ruby_xml_node, node);
-  Check_Type(key, T_STRING);
+  key = check_string_or_symbol( key );
+  Data_Get_Struct(self, ruby_xml_node, node); 
   
   if( val == Qnil ) {
     attr = xmlSetProp(node->node, (xmlChar*)StringValuePtr(key), NULL);
@@ -1676,10 +1901,7 @@ ruby_xml_node_property_set(VALUE self, VALUE key, VALUE val) {
     if (attr == NULL)
       return(Qnil);
   }
-  rattr = ruby_xml_attr_new(cXMLAttr, node->xd, attr);
-  Data_Get_Struct(rattr, ruby_xml_attr, rxa);
-  rxa->is_ptr = 1;
-  return(rattr);
+  return(ruby_xml_attr_new(cXMLAttr, node->xd, attr));
 }
 
 
@@ -1778,11 +2000,14 @@ ruby_xml_node_search_ns(VALUE self, VALUE ns) {
 }
 
 
+/* TODO Obsolete, remove */
 VALUE
 ruby_xml_node_set_ptr(VALUE node, int is_ptr) {
+  /*
   ruby_xml_node *rxn;
   Data_Get_Struct(node, ruby_xml_node, rxn);
   rxn->is_ptr = is_ptr;
+  */
   return(Qtrue);
 }
 
@@ -1808,8 +2033,7 @@ ruby_xml_node_sibling_set(VALUE self, VALUE rnode) {
   if (ret == NULL)
     rb_raise(eXMLNodeFailedModify, "unable to add a sibling to the document");
 
-  cnode->is_ptr = 1;
-  return(ruby_xml_node_new2(cXMLNode, pnode->xd, ret));
+  return(ruby_xml_node_new_ptr(cXMLNode, pnode->xd, ret));
 }
 
 
@@ -1999,8 +2223,6 @@ ruby_xml_node_xinclude_start_q(VALUE self) {
 }
 
 
-// TODO my gut tells me this is where our sigseg etc. problems start...      
-
 /*
  * call-seq:
  *    node.copy => node
@@ -2009,19 +2231,18 @@ ruby_xml_node_xinclude_start_q(VALUE self) {
  */
 VALUE
 ruby_xml_node_copy(VALUE self, VALUE deep) {   /* MUFF */
-  ruby_xml_node *rxn, *n_rxn;
-  VALUE n_node;
+  ruby_xml_node *rxn;
+  xmlNode *copy;
   
   Data_Get_Struct(self, ruby_xml_node, rxn);
-
-  n_node = ruby_xml_node_new(cXMLNode, NULL); // class??
-  Data_Get_Struct(n_node, ruby_xml_node, n_rxn);
-
-  n_rxn->node = xmlCopyNode( rxn->node, ((deep==Qnil)||(deep==Qfalse))?0:1 );
-  if (rxn->node == NULL)
-    return(Qnil);
-
-  return n_node;
+  copy = xmlCopyNode( rxn->node, ((deep==Qnil)||(deep==Qfalse))?0:1 );
+  copy->_private = (void*)0;
+  
+  if (copy == NULL) {
+    return Qnil;
+  } else {    
+    return(ruby_xml_node_new(cXMLNode, copy));
+  }
 }
 
 
@@ -2053,7 +2274,12 @@ ruby_init_xml_node(void) {
   rb_define_const(cXMLNode, "XLINK_TYPE_SIMPLE", INT2NUM(1));
 
   rb_define_singleton_method(cXMLNode, "new", ruby_xml_node_initialize, -1);
-
+  rb_define_singleton_method(cXMLNode, "new_cdata", ruby_xml_node_cdata_initialize, -1);
+  rb_define_singleton_method(cXMLNode, "new_comment", ruby_xml_node_comment_initialize, -1); 
+  
+  VALUE singleton = rb_singleton_class(cXMLNode);
+  rb_define_alias(singleton, "new_element", "new");
+  
   rb_define_method(cXMLNode, "<<", ruby_xml_node_content_add, 1);
   rb_define_method(cXMLNode, "[]", ruby_xml_node_property_get, 1);
   rb_define_method(cXMLNode, "[]=", ruby_xml_node_property_set, 2);
@@ -2104,6 +2330,7 @@ ruby_init_xml_node(void) {
   rb_define_method(cXMLNode, "namespace=", ruby_xml_node_namespace_set, -1);  
   rb_define_method(cXMLNode, "next", ruby_xml_node_next_get, 0);
   rb_define_method(cXMLNode, "next?", ruby_xml_node_next_q, 0);
+  rb_define_method(cXMLNode, "next=", ruby_xml_node_next_set, 1);
   rb_define_method(cXMLNode, "node_type", ruby_xml_node_type, 0);
   rb_define_method(cXMLNode, "node_type_name", ruby_xml_node_type_name, 0);
   rb_define_method(cXMLNode, "notation?", ruby_xml_node_notation_q, 0);
@@ -2118,6 +2345,7 @@ ruby_init_xml_node(void) {
   rb_define_method(cXMLNode, "pointer", ruby_xml_node_pointer, 1);
   rb_define_method(cXMLNode, "prev", ruby_xml_node_prev_get, 0);
   rb_define_method(cXMLNode, "prev?", ruby_xml_node_prev_q, 0);
+  rb_define_method(cXMLNode, "prev=", ruby_xml_node_prev_set, 1);
   rb_define_method(cXMLNode, "property", ruby_xml_node_property_get, 1);
   rb_define_method(cXMLNode, "properties", ruby_xml_node_properties_get, 0);
   rb_define_method(cXMLNode, "properties?", ruby_xml_node_properties_q, 0);