nokogiri 1.5.10 → 1.13.0

data/ext/nokogiri/xml_node_set.c

@@ -1,68 +1,107 @@
-#include <xml_node_set.h>
-#include <libxml/xpathInternals.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlNodeSet ;
 
 static ID decorate ;
 
-static int dealloc_namespace(xmlNsPtr ns)
+static void
+Check_Node_Set_Node_Type(VALUE node)
+{
+  if (!(rb_obj_is_kind_of(node, cNokogiriXmlNode) ||
+        rb_obj_is_kind_of(node, cNokogiriXmlNamespace))) {
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+  }
+}
+
+
+static
+VALUE
+ruby_object_get(xmlNodePtr c_node)
+{
+  /* see xmlElementType in libxml2 tree.h */
+  switch (c_node->type) {
+    case XML_NAMESPACE_DECL:
+      /* _private is later in the namespace struct */
+      return (VALUE)(((xmlNsPtr)c_node)->_private);
+
+    case XML_DOCUMENT_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      /* in documents we use _private to store a tuple */
+      if (DOC_RUBY_OBJECT_TEST(((xmlDocPtr)c_node))) {
+        return DOC_RUBY_OBJECT((xmlDocPtr)c_node);
+      }
+      return (VALUE)NULL;
+
+    default:
+      return (VALUE)(c_node->_private);
+  }
+}
+
+
+static void
+mark(xmlNodeSetPtr node_set)
 {
-  if (ns->href)
-    xmlFree((xmlChar *)ns->href);
-  if (ns->prefix)
-    xmlFree((xmlChar *)ns->prefix);
-  xmlFree(ns);
-  return ST_CONTINUE;
+  VALUE rb_node;
+  int jnode;
+
+  for (jnode = 0; jnode < node_set->nodeNr; jnode++) {
+    rb_node = ruby_object_get(node_set->nodeTab[jnode]);
+    if (rb_node) {
+      rb_gc_mark(rb_node);
+    }
+  }
 }
 
-static void deallocate(nokogiriNodeSetTuple *tuple)
+static void
+xpath_node_set_del(xmlNodeSetPtr cur, xmlNodePtr val)
 {
   /*
-   *  xmlXPathFreeNodeSet() contains an implicit assumption that it is being
-   *  called before any of its pointed-to nodes have been free()d. this
-   *  assumption lies in the operation where it dereferences nodeTab pointers
-   *  while searching for namespace nodes to free.
-   *
-   *  however, since Ruby's GC mechanism cannot guarantee the strict order in
-   *  which ruby objects will be GC'd, nodes may be garbage collected before a
-   *  nodeset containing pointers to those nodes. (this is true regardless of
-   *  how we declare dependencies between objects with rb_gc_mark().)
-   *
-   *  as a result, xmlXPathFreeNodeSet() will perform unsafe memory operations,
-   *  and calling it would be evil.
-   *
-   *  so here, we *manually* free the set of namespace nodes that was
-   *  constructed at initialization time (see Nokogiri_wrap_xml_node_set()), as
-   *  well as the NodeSet, without using the official xmlXPathFreeNodeSet().
-   *
-   *  there's probably a lesson in here somewhere about intermingling, within a
-   *  single array, structs with different memory-ownership semantics. or more
-   *  generally, a lesson about building an API in C/C++ that does not contain
-   *  assumptions about the strict order in which memory will be released. hey,
-   *  that sounds like a great idea for a blog post! get to it!
-   *
-   *  "In Valgrind We Trust." seriously.
+   * For reasons outlined in xml_namespace.c, here we reproduce xmlXPathNodeSetDel() except for the
+   * offending call to xmlXPathNodeSetFreeNs().
    */
-  xmlNodeSetPtr node_set;
+  int i;
 
-  node_set = tuple->node_set;
+  if (cur == NULL) { return; }
+  if (val == NULL) { return; }
 
-  if (!node_set)
+  /*
+   * find node in nodeTab
+   */
+  for (i = 0; i < cur->nodeNr; i++)
+    if (cur->nodeTab[i] == val) { break; }
+
+  if (i >= cur->nodeNr) {	/* not found */
     return;
+  }
+  cur->nodeNr--;
+  for (; i < cur->nodeNr; i++) {
+    cur->nodeTab[i] = cur->nodeTab[i + 1];
+  }
+  cur->nodeTab[cur->nodeNr] = NULL;
+}
 
-  NOKOGIRI_DEBUG_START(node_set) ;
-  st_foreach(tuple->namespaces, dealloc_namespace, 0);
 
-  if (node_set->nodeTab != NULL)
+static void
+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);
-  st_free_table(tuple->namespaces);
-  free(tuple);
   NOKOGIRI_DEBUG_END(node_set) ;
 }
 
-static VALUE allocate(VALUE klass)
+
+static VALUE
+allocate(VALUE klass)
 {
-  return Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), Qnil);
+  return noko_xml_node_set_wrap(xmlXPathNodeSetCreate(NULL), Qnil);
 }
 
 
@@ -70,18 +109,20 @@ static VALUE allocate(VALUE klass)
  * call-seq:
  *  dup
  *
- * Duplicate this node set
+ * Duplicate this NodeSet. Note that the Nodes contained in the NodeSet are not
+ * duplicated (similar to how Array and other Enumerable classes work).
  */
-static VALUE duplicate(VALUE self)
+static VALUE
+duplicate(VALUE self)
 {
-  nokogiriNodeSetTuple *tuple;
+  xmlNodeSetPtr node_set;
   xmlNodeSetPtr dupl;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  dupl = xmlXPathNodeSetMerge(NULL, tuple->node_set);
+  dupl = xmlXPathNodeSetMerge(NULL, node_set);
 
-  return Nokogiri_wrap_xml_node_set(dupl, rb_iv_get(self, "@document"));
+  return noko_xml_node_set_wrap(dupl, rb_iv_get(self, "@document"));
 }
 
 /*
@@ -90,12 +131,14 @@ static VALUE duplicate(VALUE self)
  *
  * Get the length of the node set
  */
-static VALUE length(VALUE self)
+static VALUE
+length(VALUE self)
 {
-  nokogiriNodeSetTuple *tuple;
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  xmlNodeSetPtr node_set;
 
-  return tuple->node_set ? INT2NUM(tuple->node_set->nodeNr) : INT2NUM(0);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
+  return node_set ? INT2NUM(node_set->nodeNr) : INT2NUM(0);
 }
 
 /*
@@ -104,17 +147,19 @@ static VALUE length(VALUE self)
  *
  * Append +node+ to the NodeSet.
  */
-static VALUE push(VALUE self, VALUE rb_node)
+static VALUE
+push(VALUE self, VALUE rb_node)
 {
-  nokogiriNodeSetTuple *tuple;
+  xmlNodeSetPtr node_set;
   xmlNodePtr node;
 
-  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
-    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+  Check_Node_Set_Node_Type(rb_node);
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
   Data_Get_Struct(rb_node, xmlNode, node);
-  xmlXPathNodeSetAdd(tuple->node_set, node);
+
+  xmlXPathNodeSetAdd(node_set, node);
+
   return self;
 }
 
@@ -126,31 +171,21 @@ static VALUE push(VALUE self, VALUE rb_node)
  *  if found, otherwise returns nil.
  */
 static VALUE
-delete(VALUE self, VALUE rb_node)
+delete (VALUE self, VALUE rb_node)
 {
-    nokogiriNodeSetTuple *tuple;
-    xmlNodePtr node;
-    xmlNodeSetPtr cur;
-    int i;
-
-    if (!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
-	rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
-
-    Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-    Data_Get_Struct(rb_node, xmlNode, node);
-    cur = tuple->node_set;
-
-    if (xmlXPathNodeSetContains(cur, node)) {
-	for (i = 0; i < cur->nodeNr; i++)
-	    if (cur->nodeTab[i] == node) break;
-
-	cur->nodeNr--;
-	for (;i < cur->nodeNr;i++)
-	    cur->nodeTab[i] = cur->nodeTab[i + 1];
-	cur->nodeTab[cur->nodeNr] = NULL;
-	return rb_node;
-    }
-    return Qnil ;
+  xmlNodeSetPtr node_set;
+  xmlNodePtr node;
+
+  Check_Node_Set_Node_Type(rb_node);
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_node, xmlNode, node);
+
+  if (xmlXPathNodeSetContains(node_set, node)) {
+    xpath_node_set_del(node_set, node);
+    return rb_node;
+  }
+  return Qnil ;
 }
 
 
@@ -160,19 +195,21 @@ delete(VALUE self, VALUE rb_node)
  *
  * Set Intersection — Returns a new NodeSet containing nodes common to the two NodeSets.
  */
-static VALUE intersection(VALUE self, VALUE rb_other)
+static VALUE
+intersection(VALUE self, VALUE rb_other)
 {
-  nokogiriNodeSetTuple *tuple, *other;
+  xmlNodeSetPtr node_set, other ;
   xmlNodeSetPtr intersection;
 
-  if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
+  if (!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet)) {
     rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
+  }
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
 
-  intersection = xmlXPathIntersection(tuple->node_set, other->node_set);
-  return Nokogiri_wrap_xml_node_set(intersection, rb_iv_get(self, "@document"));
+  intersection = xmlXPathIntersection(node_set, other);
+  return noko_xml_node_set_wrap(intersection, rb_iv_get(self, "@document"));
 }
 
 
@@ -182,18 +219,18 @@ static VALUE intersection(VALUE self, VALUE rb_other)
  *
  *  Returns true if any member of node set equals +node+.
  */
-static VALUE include_eh(VALUE self, VALUE rb_node)
+static VALUE
+include_eh(VALUE self, VALUE rb_node)
 {
-  nokogiriNodeSetTuple *tuple;
+  xmlNodeSetPtr node_set;
   xmlNodePtr node;
 
-  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
-    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+  Check_Node_Set_Node_Type(rb_node);
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
   Data_Get_Struct(rb_node, xmlNode, node);
 
-  return (xmlXPathNodeSetContains(tuple->node_set, node) ? Qtrue : Qfalse);
+  return (xmlXPathNodeSetContains(node_set, node) ? Qtrue : Qfalse);
 }
 
 
@@ -204,21 +241,23 @@ static VALUE include_eh(VALUE self, VALUE rb_node)
  * Returns a new set built by merging the set and the elements of the given
  * set.
  */
-static VALUE set_union(VALUE self, VALUE rb_other)
+static VALUE
+rb_xml_node_set_union(VALUE rb_node_set, VALUE rb_other)
 {
-  nokogiriNodeSetTuple *tuple, *other;
-  xmlNodeSetPtr new;
+  xmlNodeSetPtr c_node_set, c_other;
+  xmlNodeSetPtr c_new_node_set;
 
-  if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
+  if (!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet)) {
     rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
+  }
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
+  Data_Get_Struct(rb_node_set, xmlNodeSet, c_node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, c_other);
 
-  new = xmlXPathNodeSetMerge(NULL, tuple->node_set);
-  new = xmlXPathNodeSetMerge(new, other->node_set);
+  c_new_node_set = xmlXPathNodeSetMerge(NULL, c_node_set);
+  c_new_node_set = xmlXPathNodeSetMerge(c_new_node_set, c_other);
 
-  return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
+  return noko_xml_node_set_wrap(c_new_node_set, rb_iv_get(rb_node_set, "@document"));
 }
 
 /*
@@ -228,68 +267,66 @@ static VALUE set_union(VALUE self, VALUE rb_other)
  *  Difference - returns a new NodeSet that is a copy of this NodeSet, removing
  *  each item that also appears in +node_set+
  */
-static VALUE minus(VALUE self, VALUE rb_other)
+static VALUE
+minus(VALUE self, VALUE rb_other)
 {
-  nokogiriNodeSetTuple *tuple, *other;
+  xmlNodeSetPtr node_set, other;
   xmlNodeSetPtr new;
   int j ;
 
-  if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
+  if (!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet)) {
     rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
+  }
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
 
-  new = xmlXPathNodeSetMerge(NULL, tuple->node_set);
-  for (j = 0 ; j < other->node_set->nodeNr ; ++j) {
-    xmlXPathNodeSetDel(new, other->node_set->nodeTab[j]);
+  new = xmlXPathNodeSetMerge(NULL, node_set);
+  for (j = 0 ; j < other->nodeNr ; ++j) {
+    xpath_node_set_del(new, other->nodeTab[j]);
   }
 
-  return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
+  return noko_xml_node_set_wrap(new, rb_iv_get(self, "@document"));
 }
 
 
-static VALUE index_at(VALUE self, long offset)
+static VALUE
+index_at(VALUE self, long offset)
 {
   xmlNodeSetPtr node_set;
-  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  if (offset >= node_set->nodeNr || abs((int)offset) > node_set->nodeNr)
+  if (offset >= node_set->nodeNr || abs((int)offset) > node_set->nodeNr) {
     return Qnil;
+  }
 
-  if (offset < 0)
-    offset += node_set->nodeNr;
+  if (offset < 0) { offset += node_set->nodeNr ; }
 
-  if (XML_NAMESPACE_DECL == node_set->nodeTab[offset]->type)
-    return Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(node_set->nodeTab[offset]));
-  return Nokogiri_wrap_xml_node(Qnil, node_set->nodeTab[offset]);
+  return noko_xml_node_wrap_node_set_result(node_set->nodeTab[offset], self);
 }
 
-static VALUE subseq(VALUE self, long beg, long len)
+static VALUE
+subseq(VALUE self, long beg, long len)
 {
   long j;
-  nokogiriNodeSetTuple *tuple;
   xmlNodeSetPtr node_set;
   xmlNodeSetPtr new_set ;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  if (beg > node_set->nodeNr) return Qnil ;
-  if (beg < 0 || len < 0) return Qnil ;
+  if (beg > node_set->nodeNr) { return Qnil ; }
+  if (beg < 0 || len < 0) { return Qnil ; }
 
   if ((beg + len) > node_set->nodeNr) {
     len = node_set->nodeNr - beg ;
   }
 
   new_set = xmlXPathNodeSetCreate(NULL);
-  for (j = beg ; j < beg+len ; ++j) {
+  for (j = beg ; j < beg + len ; ++j) {
     xmlXPathNodeSetAddUnique(new_set, node_set->nodeTab[j]);
   }
-  return Nokogiri_wrap_xml_node_set(new_set, rb_iv_get(self, "@document"));
+  return noko_xml_node_set_wrap(new_set, rb_iv_get(self, "@document"));
 }
 
 /*
@@ -307,14 +344,14 @@ static VALUE subseq(VALUE self, long beg, long len)
  * count backward from the end of the +node_set+ (-1 is the last node). Returns
  * nil if the +index+ (or +start+) are out of range.
  */
-static VALUE slice(int argc, VALUE *argv, VALUE self)
+static VALUE
+slice(int argc, VALUE *argv, VALUE self)
 {
   VALUE arg ;
   long beg, len ;
   xmlNodeSetPtr node_set;
-  nokogiriNodeSetTuple *tuple;
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
   if (argc == 2) {
     beg = NUM2LONG(argv[0]);
@@ -333,15 +370,15 @@ static VALUE slice(int argc, VALUE *argv, VALUE self)
   if (FIXNUM_P(arg)) {
     return index_at(self, FIX2LONG(arg));
   }
-  
+
   /* if arg is Range */
   switch (rb_range_beg_len(arg, &beg, &len, (long)node_set->nodeNr, 0)) {
-  case Qfalse:
-    break;
-  case Qnil:
-    return Qnil;
-  default:
-    return subseq(self, beg, len);
+    case Qfalse:
+      break;
+    case Qnil:
+      return Qnil;
+    default:
+      return subseq(self, beg, len);
   }
 
   return index_at(self, NUM2LONG(arg));
@@ -354,29 +391,21 @@ static VALUE slice(int argc, VALUE *argv, VALUE self)
  *
  * Return this list as an Array
  */
-static VALUE to_array(VALUE self, VALUE rb_node)
+static VALUE
+to_array(VALUE self)
 {
-  xmlNodeSetPtr set;
-  VALUE *elts;
+  xmlNodeSetPtr node_set ;
   VALUE list;
   int i;
-  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  elts = calloc((size_t)set->nodeNr, sizeof(VALUE *));
-  for(i = 0; i < set->nodeNr; i++) {
-    if (XML_NAMESPACE_DECL == set->nodeTab[i]->type)
-      elts[i] = Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(set->nodeTab[i]));
-    else
-      elts[i] = Nokogiri_wrap_xml_node(Qnil, set->nodeTab[i]);
+  list = rb_ary_new2(node_set->nodeNr);
+  for (i = 0; i < node_set->nodeNr; i++) {
+    VALUE elt = noko_xml_node_wrap_node_set_result(node_set->nodeTab[i], self);
+    rb_ary_push(list, elt);
   }
 
-  list = rb_ary_new4((long)set->nodeNr, elts);
-
-  /*free(elts); */
-
   return list;
 }
 
@@ -386,20 +415,20 @@ static VALUE to_array(VALUE self, VALUE rb_node)
  *
  * Unlink this NodeSet and all Node objects it contains from their current context.
  */
-static VALUE unlink_nodeset(VALUE self)
+static VALUE
+unlink_nodeset(VALUE self)
 {
   xmlNodeSetPtr node_set;
   int j, nodeNr ;
-  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
   nodeNr = node_set->nodeNr ;
   for (j = 0 ; j < nodeNr ; j++) {
-    if (XML_NAMESPACE_DECL != node_set->nodeTab[j]->type) {
+    if (! NOKOGIRI_NAMESPACE_EH(node_set->nodeTab[j])) {
       VALUE node ;
       xmlNodePtr node_ptr;
-      node = Nokogiri_wrap_xml_node(Qnil, node_set->nodeTab[j]);
+      node = noko_xml_node_wrap(Qnil, node_set->nodeTab[j]);
       rb_funcall(node, rb_intern("unlink"), 0); /* modifies the C struct out from under the object */
       Data_Get_Struct(node, xmlNode, node_ptr);
       node_set->nodeTab[j] = node_ptr ;
@@ -408,60 +437,62 @@ static VALUE unlink_nodeset(VALUE self)
   return self ;
 }
 
-VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set, VALUE document)
+
+VALUE
+noko_xml_node_set_wrap(xmlNodeSetPtr c_node_set, VALUE document)
 {
-  VALUE new_set ;
-  int i;
-  xmlNodePtr cur;
-  xmlNsPtr ns;
-  nokogiriNodeSetTuple *tuple;
+  int j;
+  VALUE rb_node_set ;
 
-  new_set = Data_Make_Struct(cNokogiriXmlNodeSet, nokogiriNodeSetTuple, 0,
-			     deallocate, tuple);
+  if (c_node_set == NULL) {
+    c_node_set = xmlXPathNodeSetCreate(NULL);
+  }
 
-  tuple->node_set = node_set;
-  tuple->namespaces = st_init_numtable();
+  rb_node_set = Data_Wrap_Struct(cNokogiriXmlNodeSet, mark, deallocate, c_node_set);
 
   if (!NIL_P(document)) {
-    rb_iv_set(new_set, "@document", document);
-    rb_funcall(document, decorate, 1, new_set);
+    rb_iv_set(rb_node_set, "@document", document);
+    rb_funcall(document, decorate, 1, rb_node_set);
   }
 
-  if (node_set && node_set->nodeTab) {
-    for (i = 0; i < node_set->nodeNr; i++) {
-      cur = node_set->nodeTab[i];
-      if (cur && cur->type == XML_NAMESPACE_DECL) {
-        ns = (xmlNsPtr)cur;
-        if (ns->next && ns->next->type != XML_NAMESPACE_DECL)
-          st_insert(tuple->namespaces, (st_data_t)cur, (st_data_t)0);
-      }
-    }
+  /* make sure we create ruby objects for all the results, so they'll be marked during the GC mark phase */
+  for (j = 0 ; j < c_node_set->nodeNr ; j++) {
+    noko_xml_node_wrap_node_set_result(c_node_set->nodeTab[j], rb_node_set);
   }
 
-  return new_set ;
+  return rb_node_set ;
 }
 
-VALUE cNokogiriXmlNodeSet ;
-void init_xml_node_set(void)
+VALUE
+noko_xml_node_wrap_node_set_result(xmlNodePtr node, VALUE node_set)
+{
+  if (NOKOGIRI_NAMESPACE_EH(node)) {
+    return noko_xml_namespace_wrap_xpath_copy((xmlNsPtr)node);
+  } else {
+    return noko_xml_node_wrap(Qnil, node);
+  }
+}
+
+
+void
+noko_init_xml_node_set(void)
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml      = rb_define_module_under(nokogiri, "XML");
-  VALUE klass    = rb_define_class_under(xml, "NodeSet", rb_cObject);
-  cNokogiriXmlNodeSet = klass;
-
-  rb_define_alloc_func(klass, allocate);
-  rb_define_method(klass, "length", length, 0);
-  rb_define_method(klass, "[]", slice, -1);
-  rb_define_method(klass, "slice", slice, -1);
-  rb_define_method(klass, "push", push, 1);
-  rb_define_method(klass, "|", set_union, 1);
-  rb_define_method(klass, "-", minus, 1);
-  rb_define_method(klass, "unlink", unlink_nodeset, 0);
-  rb_define_method(klass, "to_a", to_array, 0);
-  rb_define_method(klass, "dup", duplicate, 0);
-  rb_define_method(klass, "delete", delete, 1);
-  rb_define_method(klass, "&", intersection, 1);
-  rb_define_method(klass, "include?", include_eh, 1);
+  cNokogiriXmlNodeSet = rb_define_class_under(mNokogiriXml, "NodeSet", rb_cObject);
+
+  rb_define_alloc_func(cNokogiriXmlNodeSet, allocate);
+
+  rb_define_method(cNokogiriXmlNodeSet, "length", length, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "[]", slice, -1);
+  rb_define_method(cNokogiriXmlNodeSet, "slice", slice, -1);
+  rb_define_method(cNokogiriXmlNodeSet, "push", push, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "|", rb_xml_node_set_union, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "-", minus, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "unlink", unlink_nodeset, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "to_a", to_array, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "dup", duplicate, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "delete", delete, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "&", intersection, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "include?", include_eh, 1);
 
   decorate = rb_intern("decorate");
 }