libxml-ruby 0.9.2-x86-mswin32-60 → 0.9.3-x86-mswin32-60

data/ext/libxml/ruby_xml_attr.h

@@ -1,16 +1,16 @@
-/* $Id: ruby_xml_attr.h 351 2008-07-09 19:55:21Z cfis $ */
+/* $Id: ruby_xml_attr.h 612 2008-11-21 08:01:29Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_ATTR__
-#define __RUBY_XML_ATTR__
+#ifndef __rxml_ATTR__
+#define __rxml_ATTR__
 
 extern VALUE cXMLAttr;
 
 void ruby_init_xml_attr(void);
-VALUE ruby_xml_attr_new(xmlAttrPtr xattr);
-VALUE ruby_xml_attr_value_get(VALUE self);
-VALUE ruby_xml_attr_value_set(VALUE self, VALUE val);
-void ruby_xml_attr_free(xmlAttrPtr xattr);
-VALUE ruby_xml_attr_wrap(xmlAttrPtr xattr);
+VALUE rxml_attr_new(xmlAttrPtr xattr);
+VALUE rxml_attr_value_get(VALUE self);
+VALUE rxml_attr_value_set(VALUE self, VALUE val);
+void rxml_attr_free(xmlAttrPtr xattr);
+VALUE rxml_attr_wrap(xmlAttrPtr xattr);
 #endif

data/ext/libxml/ruby_xml_attributes.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_attributes.c 300 2008-07-01 19:14:15Z cfis $ */
+/* $Id: rxml_attributes.c 300 2008-07-01 19:14:15Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -35,18 +35,18 @@
 VALUE cXMLAttributes;
 
 void
-ruby_xml_attributes_mark(xmlNodePtr xnode) {
-  ruby_xml_node_mark_common(xnode);
+rxml_attributes_mark(xmlNodePtr xnode) {
+  rxml_node_mark_common(xnode);
 }
 
 /*
  * Creates a  new attributes instance.  Not exposed to ruby.
  */
 VALUE
-ruby_xml_attributes_new(xmlNodePtr xnode)
+rxml_attributes_new(xmlNodePtr xnode)
 {
   return Data_Wrap_Struct(cXMLAttributes,
-                          ruby_xml_attributes_mark, NULL,
+                          rxml_attributes_mark, NULL,
                           xnode);
 }
 
@@ -59,10 +59,10 @@ ruby_xml_attributes_new(xmlNodePtr xnode)
  *  doc.root.attributes.node == doc.root
  */
 VALUE
-ruby_xml_attributes_node_get(VALUE self) {
+rxml_attributes_node_get(VALUE self) {
   xmlNodePtr xnode;
   Data_Get_Struct(self, xmlNode, xnode);
-  return(ruby_xml_node2_wrap(cXMLNode, xnode));
+  return(rxml_node2_wrap(cXMLNode, xnode));
 }
 
 
@@ -76,8 +76,8 @@ ruby_xml_attributes_node_get(VALUE self) {
  *
  *  doc.root.attributes.get_attribute("foo")
  */
-VALUE
-ruby_xml_attributes_get_attribute(VALUE self, VALUE name) {
+static VALUE
+rxml_attributes_get_attribute(VALUE self, VALUE name) {
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
 
@@ -88,7 +88,7 @@ ruby_xml_attributes_get_attribute(VALUE self, VALUE name) {
   xattr = xmlHasProp(xnode, (xmlChar*)StringValuePtr(name));
   
   if (xattr)
-    return(ruby_xml_attr_wrap(xattr));
+    return(rxml_attr_wrap(xattr));
   else
     return(Qnil);
 }
@@ -104,8 +104,8 @@ ruby_xml_attributes_get_attribute(VALUE self, VALUE name) {
  *
  *  doc.root.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
  */
-VALUE
-ruby_xml_attributes_get_attribute_ns(VALUE self, VALUE namespace, VALUE name) {
+static VALUE
+rxml_attributes_get_attribute_ns(VALUE self, VALUE namespace, VALUE name) {
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
 
@@ -116,7 +116,7 @@ ruby_xml_attributes_get_attribute_ns(VALUE self, VALUE namespace, VALUE name) {
   xattr = xmlHasNsProp(xnode, (xmlChar*)StringValuePtr(name), (xmlChar*)StringValuePtr(namespace));
   
   if (xattr)
-    return(ruby_xml_attr_wrap(xattr));
+    return(rxml_attr_wrap(xattr));
   else
     return(Qnil);
 }
@@ -133,12 +133,12 @@ ruby_xml_attributes_get_attribute_ns(VALUE self, VALUE namespace, VALUE name) {
  *  doc.root.attributes['att'] -> 'some value'
  */
 VALUE
-ruby_xml_attributes_attribute_get(VALUE self, VALUE name) {
-  VALUE xattr = ruby_xml_attributes_get_attribute(self, name);
+rxml_attributes_attribute_get(VALUE self, VALUE name) {
+  VALUE xattr = rxml_attributes_get_attribute(self, name);
   if NIL_P(xattr)
     return(Qnil);
   else
-    return ruby_xml_attr_value_get(xattr);
+    return rxml_attr_value_get(xattr);
 }  
 
 /*
@@ -154,13 +154,13 @@ ruby_xml_attributes_attribute_get(VALUE self, VALUE name) {
  *  doc.root.attributes['att'] = 'some value'
  */
 VALUE
-ruby_xml_attributes_attribute_set(VALUE self, VALUE name, VALUE value) {
-  VALUE xattr = ruby_xml_attributes_get_attribute(self, name);
+rxml_attributes_attribute_set(VALUE self, VALUE name, VALUE value) {
+  VALUE xattr = rxml_attributes_get_attribute(self, name);
   if NIL_P(xattr)
   {
     VALUE args[3];
 
-    args[0] = ruby_xml_attributes_node_get(self);
+    args[0] = rxml_attributes_node_get(self);
     args[1] = name;
     args[2] = value;
 
@@ -168,7 +168,7 @@ ruby_xml_attributes_attribute_set(VALUE self, VALUE name, VALUE value) {
   }
   else
   {
-    return ruby_xml_attr_value_set(xattr, value);
+    return rxml_attr_value_set(xattr, value);
   }
 }  
 
@@ -181,8 +181,8 @@ ruby_xml_attributes_attribute_set(VALUE self, VALUE name, VALUE value) {
  *  
  *  doc.root.attributes.each {|attribute| puts attribute.name}
  */
-VALUE
-ruby_xml_attributes_each(VALUE self) {
+static VALUE
+rxml_attributes_each(VALUE self) {
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
   Data_Get_Struct(self, xmlNode, xnode);
@@ -191,7 +191,7 @@ ruby_xml_attributes_each(VALUE self) {
 
   while (xattr)
   {
-     VALUE attr = ruby_xml_attr_wrap(xattr);
+     VALUE attr = rxml_attr_wrap(xattr);
      rb_yield(attr);
      xattr = xattr->next;
   }
@@ -207,8 +207,8 @@ ruby_xml_attributes_each(VALUE self) {
  *
  *  doc.root.attributes.length
  */
-VALUE
-ruby_xml_attributes_length(VALUE self) {
+static VALUE
+rxml_attributes_length(VALUE self) {
   int length = 0;
   xmlNodePtr xnode;
   xmlAttrPtr xattr;
@@ -233,8 +233,8 @@ ruby_xml_attributes_length(VALUE self) {
  *
  *  doc.root.attributes.first
  */
-VALUE
-ruby_xml_attributes_first(VALUE self) {
+static VALUE
+rxml_attributes_first(VALUE self) {
   xmlNodePtr xnode;
   Data_Get_Struct(self, xmlNode, xnode);
 
@@ -242,7 +242,7 @@ ruby_xml_attributes_first(VALUE self) {
     xmlAttrPtr xattr = xnode->properties;
     
     if (xattr) {
-      return(ruby_xml_attr_wrap(xattr));
+      return(rxml_attr_wrap(xattr));
     }
   } 
   return(Qnil);
@@ -258,12 +258,12 @@ void
 ruby_init_xml_attributes(void) {
   cXMLAttributes = rb_define_class_under(mXML, "Attributes", rb_cObject);
   rb_include_module(cXMLAttributes, rb_mEnumerable);
-  rb_define_method(cXMLAttributes, "node", ruby_xml_attributes_node_get, 0);
-  rb_define_method(cXMLAttributes, "get_attribute", ruby_xml_attributes_get_attribute, 1);
-  rb_define_method(cXMLAttributes, "get_attribute_ns", ruby_xml_attributes_get_attribute_ns, 2);
-  rb_define_method(cXMLAttributes, "[]", ruby_xml_attributes_attribute_get, 1);
-  rb_define_method(cXMLAttributes, "[]=", ruby_xml_attributes_attribute_set, 2);
-  rb_define_method(cXMLAttributes, "each", ruby_xml_attributes_each, 0);
-  rb_define_method(cXMLAttributes, "length", ruby_xml_attributes_length, 0);
-  rb_define_method(cXMLAttributes, "first", ruby_xml_attributes_first, 0);
+  rb_define_method(cXMLAttributes, "node", rxml_attributes_node_get, 0);
+  rb_define_method(cXMLAttributes, "get_attribute", rxml_attributes_get_attribute, 1);
+  rb_define_method(cXMLAttributes, "get_attribute_ns", rxml_attributes_get_attribute_ns, 2);
+  rb_define_method(cXMLAttributes, "[]", rxml_attributes_attribute_get, 1);
+  rb_define_method(cXMLAttributes, "[]=", rxml_attributes_attribute_set, 2);
+  rb_define_method(cXMLAttributes, "each", rxml_attributes_each, 0);
+  rb_define_method(cXMLAttributes, "length", rxml_attributes_length, 0);
+  rb_define_method(cXMLAttributes, "first", rxml_attributes_first, 0);
 }

data/ext/libxml/ruby_xml_attributes.h

@@ -1,17 +1,17 @@
-/* $Id: ruby_xml_attributes.h 282 2008-07-01 06:44:30Z cfis $ */
+/* $Id: rxml_attributes.h 282 2008-07-01 06:44:30Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_ATTRIBUTES__
-#define __RUBY_XML_ATTRIBUTES__
+#ifndef __rxml_ATTRIBUTES__
+#define __rxml_ATTRIBUTES__
 
 extern VALUE cXMLAttributesibutes;
 
 void ruby_init_xml_attributes(void);
-VALUE ruby_xml_attributes_new(xmlNodePtr xnode);
+VALUE rxml_attributes_new(xmlNodePtr xnode);
 
-VALUE ruby_xml_attributes_attribute_get(VALUE self, VALUE name);
-VALUE ruby_xml_attributes_attribute_set(VALUE self, VALUE name, VALUE value);
+VALUE rxml_attributes_attribute_get(VALUE self, VALUE name);
+VALUE rxml_attributes_attribute_set(VALUE self, VALUE name, VALUE value);
 
 
 #endif

data/ext/libxml/ruby_xml_document.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_document.c 575 2008-11-18 09:22:15Z cfis $ */
+/* $Id: ruby_xml_document.c 614 2008-11-22 08:04:39Z cfis $ */
 
 /*
 * Document-class: LibXML::XML::Document
@@ -34,105 +34,19 @@
 
 VALUE cXMLDocument;
 
-
-/* We have to make sure that documents are freed after
-   XPathObjects.  The Ruby gc does not guarantee this
-   at shutdown or in normal operation when a document,
-   xpath context and xpath object form a cycle.  So
-   we implement this simple reference counting scheme.
-   It works as you'd expect, except with a simple twist.
-   If a document is freed, but still has outstanding
-   references, its reference count is made negative.  Thus
-   if it has ref_count of 1, then its becomes -1.  At that
-   point, decrement will increase the account to 0, and 
-   once it reaches 0, the document is freed. */
-
-static st_table *ref_count_table = 0;
-
 void
-ruby_xml_document_internal_free(xmlDocPtr xdoc) {
-  st_delete(ref_count_table, (st_data_t*)&xdoc, 0);
+rxml_document_free(xmlDocPtr xdoc) {
   xdoc->_private = NULL;
   xmlFreeDoc(xdoc);
-}
-
-int
-ruby_xml_document_incr(xmlDocPtr xdoc) {
-  int ref_count;
-
-  if (st_lookup(ref_count_table, (st_data_t)xdoc, (st_data_t*)&ref_count))
-  {
-    ref_count++;
-    st_insert(ref_count_table, (st_data_t)xdoc, (st_data_t)ref_count);
-  }
-  else
-  {
-    ref_count = 1;
-    st_add_direct(ref_count_table, (st_data_t)xdoc, (st_data_t)ref_count);
-  }
-  
-  return ref_count;
-}
-
-int
-ruby_xml_document_decr(xmlDocPtr xdoc) {
-  int ref_count = 0;
-
-  if (!st_lookup(ref_count_table, (st_data_t)xdoc, (st_data_t*)&ref_count)) 
-    rb_raise(rb_eRuntimeError, "Document does not have a reference count.");
-
-  if (ref_count == 0)
-  {
-    rb_raise(rb_eRuntimeError, "Document already has no references.");
-  }
-  else if (ref_count > 0)
-  {
-    ref_count--;
-  }
-  else
-  {
-    ref_count++;
-    if (ref_count == 0)
-    {
-      ruby_xml_document_internal_free(xdoc);
-      return ref_count;
-    }
-  }
-
-  st_insert(ref_count_table, (st_data_t)xdoc, ref_count);
-  return ref_count;
-}
-
-void
-ruby_xml_document_free(xmlDocPtr xdoc) {
-  int ref_count;
-
-  if (!st_lookup(ref_count_table, (st_data_t)xdoc, (st_data_t*)&ref_count))
-  {
-    ruby_xml_document_internal_free(xdoc);
-  }
-  else if (ref_count == 0)
-  {
-    ruby_xml_document_internal_free(xdoc);
-  }
-  else if (ref_count > 0)
-  {
-    ref_count *= -1;
-    st_insert(ref_count_table, (st_data_t)xdoc, ref_count);
-  }
-  else 
-  {
-    rb_raise(rb_eRuntimeError, "Ruby is attempting to free document twice.");
-  }
 }   
  
 void
-ruby_xml_document_mark(xmlDocPtr xdoc) {
+rxml_document_mark(xmlDocPtr xdoc) {
   rb_gc_mark(LIBXML_STATE);
 }
 
 VALUE
-ruby_xml_document_wrap(xmlDocPtr xdoc) {
+rxml_document_wrap(xmlDocPtr xdoc) {
   VALUE result;
 
   // This node is already wrapped
@@ -142,7 +56,7 @@ ruby_xml_document_wrap(xmlDocPtr xdoc) {
   }
   else  
   {
-    result = Data_Wrap_Struct(cXMLDocument, ruby_xml_document_mark, ruby_xml_document_free, xdoc);
+    result = Data_Wrap_Struct(cXMLDocument, rxml_document_mark, rxml_document_free, xdoc);
     xdoc->_private = (void*)result;
   }
      
@@ -157,9 +71,9 @@ ruby_xml_document_wrap(xmlDocPtr xdoc) {
  * Alocates a new XML::Document, optionally specifying the
  * XML version.
  */
-VALUE
-ruby_xml_document_alloc(VALUE klass) {
-  return Data_Wrap_Struct(klass, ruby_xml_document_mark, ruby_xml_document_free, NULL);
+static VALUE
+rxml_document_alloc(VALUE klass) {
+  return Data_Wrap_Struct(klass, rxml_document_mark, rxml_document_free, NULL);
 }
 
 /*
@@ -169,8 +83,8 @@ ruby_xml_document_alloc(VALUE klass) {
  * Initializes a new XML::Document, optionally specifying the
  * XML version.
  */
-VALUE
-ruby_xml_document_initialize(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_initialize(int argc, VALUE *argv, VALUE self) {
   xmlDocPtr xdoc;
   VALUE xmlver;
 
@@ -200,8 +114,8 @@ ruby_xml_document_initialize(int argc, VALUE *argv, VALUE self) {
  * 
  * Obtain this document's compression mode identifier.
  */
-VALUE
-ruby_xml_document_compression_get(VALUE self) {
+static VALUE
+rxml_document_compression_get(VALUE self) {
 #ifdef HAVE_ZLIB_H
   xmlDocPtr xdoc;
 
@@ -226,8 +140,8 @@ ruby_xml_document_compression_get(VALUE self) {
  * 
  * Set this document's compression mode.
  */
-VALUE
-ruby_xml_document_compression_set(VALUE self, VALUE num) {
+static VALUE
+rxml_document_compression_set(VALUE self, VALUE num) {
 #ifdef HAVE_ZLIB_H
   xmlDocPtr xdoc;
 
@@ -259,8 +173,8 @@ ruby_xml_document_compression_set(VALUE self, VALUE num) {
  * 
  * Determine whether this document is compressed.
  */
-VALUE
-ruby_xml_document_compression_q(VALUE self) {
+static VALUE
+rxml_document_compression_q(VALUE self) {
 #ifdef HAVE_ZLIB_H
   xmlDocPtr xdoc;
 
@@ -283,15 +197,15 @@ ruby_xml_document_compression_q(VALUE self) {
  * 
  * Get this document's child node.
  */
-VALUE
-ruby_xml_document_child_get(VALUE self) {
+static VALUE
+rxml_document_child_get(VALUE self) {
   xmlDocPtr xdoc;
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   if (xdoc->children == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, xdoc->children);
+  return rxml_node2_wrap(cXMLNode, xdoc->children);
 }
 
 
@@ -301,8 +215,8 @@ ruby_xml_document_child_get(VALUE self) {
  * 
  * Determine whether this document has a child node.
  */
-VALUE
-ruby_xml_document_child_q(VALUE self) {
+static VALUE
+rxml_document_child_q(VALUE self) {
   xmlDocPtr xdoc;
   Data_Get_Struct(self, xmlDoc, xdoc);
 
@@ -320,8 +234,8 @@ ruby_xml_document_child_q(VALUE self) {
  * Dump this document's XML to the specified IO stream.
  * If no stream is specified, stdout is used.
  */
-VALUE
-ruby_xml_document_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_dump(int argc, VALUE *argv, VALUE self) {
   OpenFile *fptr;
   VALUE io;
   FILE *out;
@@ -358,8 +272,8 @@ ruby_xml_document_dump(int argc, VALUE *argv, VALUE self) {
  * 
  * Debug version of dump.
  */
-VALUE
-ruby_xml_document_debug_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_debug_dump(int argc, VALUE *argv, VALUE self) {
 #ifdef LIBXML_DEBUG_ENABLED
   OpenFile *fptr;
   VALUE io;
@@ -402,8 +316,8 @@ ruby_xml_document_debug_dump(int argc, VALUE *argv, VALUE self) {
  * Debug-dump this document's header to the specified IO stream.
  * If no stream is specified, stdout is used.
  */
-VALUE
-ruby_xml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) {
 #ifdef LIBXML_DEBUG_ENABLED
   OpenFile *fptr;
   VALUE io;
@@ -449,8 +363,8 @@ ruby_xml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) {
  * specified, it must be a boolean that determines whether 
  * spacing is used.
  */
-VALUE
-ruby_xml_document_format_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_format_dump(int argc, VALUE *argv, VALUE self) {
   OpenFile *fptr;
   VALUE bool, io;
   FILE *out;
@@ -504,10 +418,10 @@ ruby_xml_document_format_dump(int argc, VALUE *argv, VALUE self) {
  * 
  * *Deprecated* in favour of format_dump.
  */
-VALUE
-ruby_xml_document_debug_format_dump(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_debug_format_dump(int argc, VALUE *argv, VALUE self) {
   rb_warn("debug_format_dump has been deprecaited, use format_dump instead");
-  return(ruby_xml_document_format_dump(argc, argv, self));
+  return(rxml_document_format_dump(argc, argv, self));
 }
 
 
@@ -517,8 +431,8 @@ ruby_xml_document_debug_format_dump(int argc, VALUE *argv, VALUE self) {
  * 
  * Obtain the encoding specified by this document.
  */
-VALUE
-ruby_xml_document_encoding_get(VALUE self) {
+static VALUE
+rxml_document_encoding_get(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -535,15 +449,15 @@ ruby_xml_document_encoding_get(VALUE self) {
  * 
  * Set the encoding for this document.
  */
-VALUE
-ruby_xml_document_encoding_set(VALUE self, VALUE encoding) {
+static VALUE
+rxml_document_encoding_set(VALUE self, VALUE encoding) {
   xmlDocPtr xdoc;
 
 
   Check_Type(encoding, T_STRING);
   Data_Get_Struct(self, xmlDoc, xdoc);
   xdoc->encoding = xmlStrdup(StringValuePtr(encoding));
-  return(ruby_xml_document_encoding_get(self));
+  return(rxml_document_encoding_get(self));
 }
 
 /*
@@ -552,8 +466,8 @@ ruby_xml_document_encoding_set(VALUE self, VALUE encoding) {
  * 
  * Obtain the last node.
  */
-VALUE
-ruby_xml_document_last_get(VALUE self) {
+static VALUE
+rxml_document_last_get(VALUE self) {
   xmlDocPtr xdoc;
 
 
@@ -562,7 +476,7 @@ ruby_xml_document_last_get(VALUE self) {
   if (xdoc->last == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, xdoc->last);
+  return rxml_node2_wrap(cXMLNode, xdoc->last);
 }
 
 
@@ -572,8 +486,8 @@ ruby_xml_document_last_get(VALUE self) {
  * 
  * Determine whether there is a last node.
  */
-VALUE
-ruby_xml_document_last_q(VALUE self) {
+static VALUE
+rxml_document_last_q(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -591,8 +505,8 @@ ruby_xml_document_last_q(VALUE self) {
  * 
  * Obtain the next node.
  */
-VALUE
-ruby_xml_document_next_get(VALUE self) {
+static VALUE
+rxml_document_next_get(VALUE self) {
   xmlDocPtr xdoc;
 
 
@@ -601,7 +515,7 @@ ruby_xml_document_next_get(VALUE self) {
   if (xdoc->next == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, xdoc->next);
+  return rxml_node2_wrap(cXMLNode, xdoc->next);
 }
 
 
@@ -611,8 +525,8 @@ ruby_xml_document_next_get(VALUE self) {
  * 
  * Determine whether there is a next node.
  */
-VALUE
-ruby_xml_document_next_q(VALUE self) {
+static VALUE
+rxml_document_next_q(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -630,8 +544,8 @@ ruby_xml_document_next_q(VALUE self) {
  * 
  * Obtain the parent node.
  */
-VALUE
-ruby_xml_document_parent_get(VALUE self) {
+static VALUE
+rxml_document_parent_get(VALUE self) {
   xmlDocPtr xdoc;
 
 
@@ -640,7 +554,7 @@ ruby_xml_document_parent_get(VALUE self) {
   if (xdoc->parent == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, xdoc->parent);
+  return rxml_node2_wrap(cXMLNode, xdoc->parent);
 }
 
 
@@ -650,8 +564,8 @@ ruby_xml_document_parent_get(VALUE self) {
  * 
  * Determine whether there is a parent node.
  */
-VALUE
-ruby_xml_document_parent_q(VALUE self) {
+static VALUE
+rxml_document_parent_q(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -669,8 +583,8 @@ ruby_xml_document_parent_q(VALUE self) {
  * 
  * Obtain the previous node.
  */
-VALUE
-ruby_xml_document_prev_get(VALUE self) {
+static VALUE
+rxml_document_prev_get(VALUE self) {
   xmlDocPtr xdoc;
 
 
@@ -679,7 +593,7 @@ ruby_xml_document_prev_get(VALUE self) {
   if (xdoc->prev == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, xdoc->prev);
+  return rxml_node2_wrap(cXMLNode, xdoc->prev);
 }
 
 
@@ -689,8 +603,8 @@ ruby_xml_document_prev_get(VALUE self) {
  * 
  * Determine whether there is a previous node.
  */
-VALUE
-ruby_xml_document_prev_q(VALUE self) {
+static VALUE
+rxml_document_prev_q(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -708,8 +622,8 @@ ruby_xml_document_prev_q(VALUE self) {
  * 
  * Obtain the root node.
  */
-VALUE
-ruby_xml_document_root_get(VALUE self) {
+static VALUE
+rxml_document_root_get(VALUE self) {
   xmlDocPtr xdoc;
 
   xmlNodePtr root;
@@ -720,7 +634,7 @@ ruby_xml_document_root_get(VALUE self) {
   if (root == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, root);
+  return rxml_node2_wrap(cXMLNode, root);
 }
 
 
@@ -730,8 +644,8 @@ ruby_xml_document_root_get(VALUE self) {
  * 
  * Set the root node.
  */
-VALUE
-ruby_xml_document_root_set(VALUE self, VALUE node) {
+static VALUE
+rxml_document_root_set(VALUE self, VALUE node) {
   xmlDocPtr xdoc;
   xmlNodePtr xroot, xnode;
 
@@ -744,7 +658,7 @@ ruby_xml_document_root_set(VALUE self, VALUE node) {
   if (xroot == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, xroot);
+  return rxml_node2_wrap(cXMLNode, xroot);
 }
 
 
@@ -760,8 +674,8 @@ ruby_xml_document_root_set(VALUE self, VALUE node) {
  *  format: Specifies whether formatting spaces should be added.
  *  returns: The number of bytes written or -1 in case of error. 
  */
-VALUE
-ruby_xml_document_save(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_save(int argc, VALUE *argv, VALUE self) {
   xmlDocPtr xdoc;
 
   const char *filename;
@@ -804,8 +718,8 @@ ruby_xml_document_save(int argc, VALUE *argv, VALUE self) {
  * 
  * Determine whether this is a standalone document.
  */
-VALUE
-ruby_xml_document_standalone_q(VALUE self) {
+static VALUE
+rxml_document_standalone_q(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -828,8 +742,8 @@ ruby_xml_document_standalone_q(VALUE self) {
  * The encoding is not applied to the document, but is
  * encoding target of the resulting string.
  */
-VALUE
-ruby_xml_document_to_s(int argc, VALUE *argv, VALUE self) {
+static VALUE
+rxml_document_to_s(int argc, VALUE *argv, VALUE self) {
   xmlDocPtr xdoc;
 
   xmlChar *result, *encoding=NULL;
@@ -884,8 +798,8 @@ ruby_xml_document_to_s(int argc, VALUE *argv, VALUE self) {
  * 
  * Obtain this document's source URL, if any.
  */
-VALUE
-ruby_xml_document_url_get(VALUE self) {
+static VALUE
+rxml_document_url_get(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -902,8 +816,8 @@ ruby_xml_document_url_get(VALUE self) {
  * 
  * Obtain the XML version specified by this document.
  */
-VALUE
-ruby_xml_document_version_get(VALUE self) {
+static VALUE
+rxml_document_version_get(VALUE self) {
   xmlDocPtr xdoc;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
@@ -920,8 +834,8 @@ ruby_xml_document_version_get(VALUE self) {
  * 
  * Process xinclude directives in this document. 
  */
-VALUE
-ruby_xml_document_xinclude(VALUE self) {
+static VALUE
+rxml_document_xinclude(VALUE self) {
 #ifdef LIBXML_XINCLUDE_ENABLED
   xmlDocPtr xdoc;
 
@@ -935,7 +849,7 @@ ruby_xml_document_xinclude(VALUE self) {
   }
   else
   {
-    ruby_xml_raise(&xmlLastError);
+    rxml_raise(&xmlLastError);
     return Qnil;
   }
 #else
@@ -980,17 +894,17 @@ LibXML_validity_warning(void * ctxt, const char * msg, va_list ap)
  * The block is called with two argument, the message and a flag indication
  * if the message is an error (true) or a warning (false).
  */
-VALUE
-ruby_xml_document_validate_schema(VALUE self, VALUE schema) {
+static VALUE
+rxml_document_validate_schema(VALUE self, VALUE schema) {
   xmlSchemaValidCtxtPtr vptr;
   xmlDocPtr xdoc;
-  ruby_xml_schema *c_schema;
+  xmlSchemaPtr xschema;
   int is_invalid;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
-  Data_Get_Struct(schema, ruby_xml_schema, c_schema);
+  Data_Get_Struct(schema, xmlSchema, xschema);
 
-  vptr = xmlSchemaNewValidCtxt(c_schema->schema);
+  vptr = xmlSchemaNewValidCtxt(xschema);
 
   xmlSchemaSetValidErrors(vptr, (xmlSchemaValidityErrorFunc)LibXML_validity_error,
                                 (xmlSchemaValidityWarningFunc)LibXML_validity_warning, NULL);
@@ -999,9 +913,10 @@ ruby_xml_document_validate_schema(VALUE self, VALUE schema) {
   xmlSchemaFreeValidCtxt(vptr);
   if (is_invalid) 
   {
-    ruby_xml_raise(&xmlLastError);
+    rxml_raise(&xmlLastError);
     return Qfalse;
-  } else
+  } 
+  else
   {
 	  return Qtrue;
   }
@@ -1017,17 +932,17 @@ ruby_xml_document_validate_schema(VALUE self, VALUE schema) {
  * The block is called with two argument, the message and a flag indication
  * if the message is an error (true) or a warning (false).
  */
-VALUE
-ruby_xml_document_validate_relaxng(VALUE self, VALUE relaxng) {
+static VALUE
+rxml_document_validate_relaxng(VALUE self, VALUE relaxng) {
   xmlRelaxNGValidCtxtPtr vptr;
   xmlDocPtr xdoc;
-  ruby_xml_relaxng *c_relaxng;
+  xmlRelaxNGPtr xrelaxng;
   int is_invalid;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
-  Data_Get_Struct(relaxng, ruby_xml_relaxng, c_relaxng);
+  Data_Get_Struct(relaxng, xmlRelaxNG, xrelaxng);
 
-  vptr = xmlRelaxNGNewValidCtxt(c_relaxng->relaxng);
+  vptr = xmlRelaxNGNewValidCtxt(xrelaxng);
 
   xmlRelaxNGSetValidErrors(vptr, (xmlRelaxNGValidityErrorFunc)LibXML_validity_error,
                                 (xmlRelaxNGValidityWarningFunc)LibXML_validity_warning, NULL);
@@ -1036,7 +951,7 @@ ruby_xml_document_validate_relaxng(VALUE self, VALUE relaxng) {
   xmlRelaxNGFreeValidCtxt(vptr);
   if (is_invalid) 
   {
-    ruby_xml_raise(&xmlLastError);
+    rxml_raise(&xmlLastError);
     return Qfalse;
   } else 
   {
@@ -1051,15 +966,15 @@ ruby_xml_document_validate_relaxng(VALUE self, VALUE relaxng) {
  * 
  * Validate this document against the specified XML::DTD.
  */
-VALUE
-ruby_xml_document_validate_dtd(VALUE self, VALUE dtd) {
+static VALUE
+rxml_document_validate_dtd(VALUE self, VALUE dtd) {
   VALUE error = Qnil;
   xmlValidCtxt ctxt;
   xmlDocPtr xdoc;
-  ruby_xml_dtd *c_dtd;
+  xmlDtdPtr xdtd;
 
   Data_Get_Struct(self, xmlDoc, xdoc);
-  Data_Get_Struct(dtd, ruby_xml_dtd, c_dtd);
+  Data_Get_Struct(dtd, xmlDtd, xdtd);
 
   ctxt.userData = &error;
   ctxt.error = (xmlValidityErrorFunc)LibXML_validity_error;
@@ -1070,13 +985,13 @@ ruby_xml_document_validate_dtd(VALUE self, VALUE dtd) {
   ctxt.vstateNr = 0;
   ctxt.vstateTab = NULL;
 
-  if (xmlValidateDtd(&ctxt, xdoc, c_dtd->dtd))
+  if (xmlValidateDtd(&ctxt, xdoc, xdtd))
   {
     return(Qtrue);
   }
   else
   {
-    ruby_xml_raise(&xmlLastError);
+    rxml_raise(&xmlLastError);
     return Qfalse;
   }
 }
@@ -1090,9 +1005,9 @@ ruby_xml_document_validate_dtd(VALUE self, VALUE dtd) {
  * XML::Reader.walker().
  */
 static VALUE
-ruby_xml_document_reader(VALUE self)
+rxml_document_reader(VALUE self)
 {
-  return ruby_xml_reader_new_walker(cXMLReader, self);
+  return rxml_reader_new_walker(cXMLReader, self);
 }
 
 // Rdoc needs to know 
@@ -1103,42 +1018,40 @@ ruby_xml_document_reader(VALUE self)
 
 void
 ruby_init_xml_document(void) {
-  ref_count_table = st_init_numtable();
-
   cXMLDocument = rb_define_class_under(mXML, "Document", rb_cObject);
-  rb_define_alloc_func(cXMLDocument, ruby_xml_document_alloc);
-
-  rb_define_method(cXMLDocument, "initialize", ruby_xml_document_initialize, -1);
-  rb_define_method(cXMLDocument, "child", ruby_xml_document_child_get, 0);
-  rb_define_method(cXMLDocument, "child?", ruby_xml_document_child_q, 0);
-  rb_define_method(cXMLDocument, "compression", ruby_xml_document_compression_get, 0);
-  rb_define_method(cXMLDocument, "compression=", ruby_xml_document_compression_set, 1);
-  rb_define_method(cXMLDocument, "compression?", ruby_xml_document_compression_q, 0);
-  rb_define_method(cXMLDocument, "dump", ruby_xml_document_dump, -1);
-  rb_define_method(cXMLDocument, "debug_dump", ruby_xml_document_debug_dump, -1);
-  rb_define_method(cXMLDocument, "debug_dump_head", ruby_xml_document_debug_dump_head, -1);
-  rb_define_method(cXMLDocument, "debug_format_dump", ruby_xml_document_debug_format_dump, -1);
-  rb_define_method(cXMLDocument, "encoding", ruby_xml_document_encoding_get, 0);
-  rb_define_method(cXMLDocument, "encoding=", ruby_xml_document_encoding_set, 1);
-  rb_define_method(cXMLDocument, "format_dump", ruby_xml_document_format_dump, -1);
-  rb_define_method(cXMLDocument, "last", ruby_xml_document_last_get, 0);
-  rb_define_method(cXMLDocument, "last?", ruby_xml_document_last_q, 0);
-  rb_define_method(cXMLDocument, "next", ruby_xml_document_next_get, 0);
-  rb_define_method(cXMLDocument, "next?", ruby_xml_document_next_q, 0);
-  rb_define_method(cXMLDocument, "parent", ruby_xml_document_parent_get, 0);
-  rb_define_method(cXMLDocument, "parent?", ruby_xml_document_parent_q, 0);
-  rb_define_method(cXMLDocument, "prev", ruby_xml_document_prev_get, 0);
-  rb_define_method(cXMLDocument, "prev?", ruby_xml_document_prev_q, 0);
-  rb_define_method(cXMLDocument, "root", ruby_xml_document_root_get, 0);
-  rb_define_method(cXMLDocument, "root=", ruby_xml_document_root_set, 1);
-  rb_define_method(cXMLDocument, "save", ruby_xml_document_save, -1);
-  rb_define_method(cXMLDocument, "standalone?", ruby_xml_document_standalone_q, 0);
-  rb_define_method(cXMLDocument, "to_s", ruby_xml_document_to_s, -1);
-  rb_define_method(cXMLDocument, "url", ruby_xml_document_url_get, 0);
-  rb_define_method(cXMLDocument, "version", ruby_xml_document_version_get, 0);
-  rb_define_method(cXMLDocument, "xinclude", ruby_xml_document_xinclude, 0);
-  rb_define_method(cXMLDocument, "validate", ruby_xml_document_validate_dtd, 1);
-  rb_define_method(cXMLDocument, "validate_schema", ruby_xml_document_validate_schema, 1);
-  rb_define_method(cXMLDocument, "validate_relaxng", ruby_xml_document_validate_relaxng, 1);
-  rb_define_method(cXMLDocument, "reader", ruby_xml_document_reader, 0);
+  rb_define_alloc_func(cXMLDocument, rxml_document_alloc);
+
+  rb_define_method(cXMLDocument, "initialize", rxml_document_initialize, -1);
+  rb_define_method(cXMLDocument, "child", rxml_document_child_get, 0);
+  rb_define_method(cXMLDocument, "child?", rxml_document_child_q, 0);
+  rb_define_method(cXMLDocument, "compression", rxml_document_compression_get, 0);
+  rb_define_method(cXMLDocument, "compression=", rxml_document_compression_set, 1);
+  rb_define_method(cXMLDocument, "compression?", rxml_document_compression_q, 0);
+  rb_define_method(cXMLDocument, "dump", rxml_document_dump, -1);
+  rb_define_method(cXMLDocument, "debug_dump", rxml_document_debug_dump, -1);
+  rb_define_method(cXMLDocument, "debug_dump_head", rxml_document_debug_dump_head, -1);
+  rb_define_method(cXMLDocument, "debug_format_dump", rxml_document_debug_format_dump, -1);
+  rb_define_method(cXMLDocument, "encoding", rxml_document_encoding_get, 0);
+  rb_define_method(cXMLDocument, "encoding=", rxml_document_encoding_set, 1);
+  rb_define_method(cXMLDocument, "format_dump", rxml_document_format_dump, -1);
+  rb_define_method(cXMLDocument, "last", rxml_document_last_get, 0);
+  rb_define_method(cXMLDocument, "last?", rxml_document_last_q, 0);
+  rb_define_method(cXMLDocument, "next", rxml_document_next_get, 0);
+  rb_define_method(cXMLDocument, "next?", rxml_document_next_q, 0);
+  rb_define_method(cXMLDocument, "parent", rxml_document_parent_get, 0);
+  rb_define_method(cXMLDocument, "parent?", rxml_document_parent_q, 0);
+  rb_define_method(cXMLDocument, "prev", rxml_document_prev_get, 0);
+  rb_define_method(cXMLDocument, "prev?", rxml_document_prev_q, 0);
+  rb_define_method(cXMLDocument, "root", rxml_document_root_get, 0);
+  rb_define_method(cXMLDocument, "root=", rxml_document_root_set, 1);
+  rb_define_method(cXMLDocument, "save", rxml_document_save, -1);
+  rb_define_method(cXMLDocument, "standalone?", rxml_document_standalone_q, 0);
+  rb_define_method(cXMLDocument, "to_s", rxml_document_to_s, -1);
+  rb_define_method(cXMLDocument, "url", rxml_document_url_get, 0);
+  rb_define_method(cXMLDocument, "version", rxml_document_version_get, 0);
+  rb_define_method(cXMLDocument, "xinclude", rxml_document_xinclude, 0);
+  rb_define_method(cXMLDocument, "validate", rxml_document_validate_dtd, 1);
+  rb_define_method(cXMLDocument, "validate_schema", rxml_document_validate_schema, 1);
+  rb_define_method(cXMLDocument, "validate_relaxng", rxml_document_validate_relaxng, 1);
+  rb_define_method(cXMLDocument, "reader", rxml_document_reader, 0);
 }