libxml-ruby 5.0.6 → 6.0.0

data/ext/libxml/ruby_xml_schema.c

@@ -109,11 +109,18 @@ struct _xmlSchemaImport {
 
 VALUE cXMLSchema;
 
-static void rxml_schema_free(xmlSchemaPtr xschema)
+static void rxml_schema_free(void *data)
 {
+  xmlSchemaPtr xschema = (xmlSchemaPtr)data;
   xmlSchemaFree(xschema);
 }
 
+const rb_data_type_t rxml_schema_type = {
+  "XML::Schema",
+  {NULL, rxml_schema_free, NULL},
+  NULL, NULL, 0
+};
+
 VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
 {
   VALUE result;
@@ -121,7 +128,7 @@ VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
   if (!xschema)
     rb_raise(rb_eArgError, "XML::Schema is required!");
 
-  result = Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+  result = TypedData_Wrap_Struct(cXMLSchema, &rxml_schema_type, xschema);
 
   /*
    * Create these as instance variables to provide the output of inspect/to_str some
@@ -130,7 +137,7 @@ VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
   rb_iv_set(result, "@target_namespace", QNIL_OR_STRING(xschema->targetNamespace));
   rb_iv_set(result, "@name", QNIL_OR_STRING(xschema->name));
   rb_iv_set(result, "@id", QNIL_OR_STRING(xschema->id));
-  rb_iv_set(result, "@version", QNIL_OR_STRING(xschema->name));
+  rb_iv_set(result, "@version", QNIL_OR_STRING(xschema->version));
 
   return result;
 }
@@ -179,7 +186,7 @@ static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
   xmlDocPtr xdoc;
   xmlSchemaParserCtxtPtr xparser;
 
-  Data_Get_Struct(document, xmlDoc, xdoc);
+  TypedData_Get_Struct(document, xmlDoc, &rxml_document_data_type, xdoc);
 
   xmlResetLastError();
   xparser = xmlSchemaNewDocParserCtxt(xdoc);
@@ -219,7 +226,7 @@ static VALUE rxml_schema_document(VALUE self)
 {
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
 }
@@ -254,7 +261,7 @@ static VALUE rxml_schema_namespaces(VALUE self)
   VALUE result;
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   result = rb_ary_new();
   xmlHashScan(xschema->schemasImports, (xmlHashScanner)scan_namespaces, (void *)result);
@@ -273,7 +280,7 @@ static VALUE rxml_schema_elements(VALUE self)
   VALUE result = rb_hash_new();
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
   xmlHashScan(xschema->elemDecl, (xmlHashScanner)scan_schema_element, (void *)result);
 
   return result;
@@ -300,7 +307,7 @@ static VALUE rxml_schema_imported_ns_elements(VALUE self)
   xmlSchemaPtr xschema;
   VALUE result = rb_hash_new();
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema)
   {
@@ -321,7 +328,7 @@ static VALUE rxml_schema_types(VALUE self)
   VALUE result = rb_hash_new();
   xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema != NULL && xschema->typeDecl != NULL)
   {
@@ -350,7 +357,7 @@ static VALUE rxml_schema_imported_types(VALUE self)
   xmlSchemaPtr xschema;
   VALUE result = rb_hash_new();
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema)
   {
@@ -381,7 +388,7 @@ static VALUE rxml_schema_imported_ns_types(VALUE self)
   xmlSchemaPtr xschema;
   VALUE result = rb_hash_new();
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+  TypedData_Get_Struct(self, xmlSchema, &rxml_schema_type, xschema);
 
   if (xschema)
   {

data/ext/libxml/ruby_xml_schema.h

@@ -18,6 +18,7 @@ struct _xmlSchemaItemList {
     (slot == NULL) ? Qnil : rb_str_new2((const char *)slot)
 
 extern VALUE cXMLSchema;
+extern const rb_data_type_t rxml_schema_type;
 
 void rxml_init_schema(void);
 

data/ext/libxml/ruby_xml_schema_attribute.c

@@ -50,11 +50,11 @@ struct _xmlSchemaAttributeUseProhib {
 
 VALUE cXMLSchemaAttribute;
 
-static void rxml_schema_attribute_free(xmlSchemaAttributeUsePtr attr)
-{
-  attr = NULL;
-  xmlFree(attr);
-}
+static const rb_data_type_t rxml_schema_attribute_type = {
+  "XML::Schema::Attribute",
+  {NULL, NULL, NULL},
+  NULL, NULL, 0
+};
 
 VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr)
 {
@@ -64,7 +64,7 @@ VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr)
   if (!attr)
     rb_raise(rb_eArgError, "XML::Schema::Attribute required!");
 
-  result = Data_Wrap_Struct(cXMLSchemaAttribute, NULL, rxml_schema_attribute_free, attr);
+  result = TypedData_Wrap_Struct(cXMLSchemaAttribute, &rxml_schema_attribute_type, attr);
 
   if (attr->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
     tns_str = ((xmlSchemaAttributeUseProhibPtr) attr)->targetNamespace;
@@ -89,7 +89,7 @@ static VALUE rxml_schema_attribute_node(VALUE self)
 {
   xmlSchemaAttributeUsePtr attr;
 
-  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
+  TypedData_Get_Struct(self, xmlSchemaAttributeUse, &rxml_schema_attribute_type, attr);
 
   return rxml_node_wrap(attr->node);
 }

data/ext/libxml/ruby_xml_schema_element.c

@@ -4,11 +4,11 @@
 
 VALUE cXMLSchemaElement;
 
-static void rxml_schema_element_free(xmlSchemaElementPtr xschema_element)
-{
-  xschema_element = NULL;
-  xmlFree(xschema_element);
-}
+static const rb_data_type_t rxml_schema_element_type = {
+  "XML::Schema::Element",
+  {NULL, NULL, NULL},
+  NULL, NULL, 0
+};
 
 VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelem)
 {
@@ -17,7 +17,7 @@ VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelem)
   if (!xelem)
     rb_raise(rb_eArgError, "XML::Schema::Element is required!");
 
-  result = Data_Wrap_Struct(cXMLSchemaElement, NULL, rxml_schema_element_free, xelem);
+  result = TypedData_Wrap_Struct(cXMLSchemaElement, &rxml_schema_element_type, xelem);
 
   rb_iv_set(result, "@name", QNIL_OR_STRING(xelem->name));
   rb_iv_set(result, "@value", QNIL_OR_STRING(xelem->value));
@@ -31,7 +31,7 @@ static VALUE rxml_schema_element_node(VALUE self)
 {
   xmlSchemaElementPtr xelem;
 
-  Data_Get_Struct(self, xmlSchemaElement, xelem);
+  TypedData_Get_Struct(self, xmlSchemaElement, &rxml_schema_element_type, xelem);
 
   return rxml_node_wrap(xelem->node);
 }
@@ -41,7 +41,7 @@ static VALUE rxml_schema_element_annot(VALUE self)
   xmlSchemaElementPtr xelem;
   VALUE annotation = Qnil;
 
-  Data_Get_Struct(self, xmlSchemaElement, xelem);
+  TypedData_Get_Struct(self, xmlSchemaElement, &rxml_schema_element_type, xelem);
 
   if ((xelem->annot != NULL) && (xelem->annot->content != NULL))
   {

data/ext/libxml/ruby_xml_schema_facet.c

@@ -7,11 +7,11 @@
 
 VALUE cXMLSchemaFacet;
 
-static void rxml_schema_facet_free(xmlSchemaFacetPtr xschema_type)
-{
-  xschema_type = NULL;
-  xmlFree(xschema_type);
-}
+static const rb_data_type_t rxml_schema_facet_type = {
+  "XML::Schema::Facet",
+  {NULL, NULL, NULL},
+  NULL, NULL, 0
+};
 
 VALUE rxml_wrap_schema_facet(xmlSchemaFacetPtr facet)
 {
@@ -20,7 +20,7 @@ VALUE rxml_wrap_schema_facet(xmlSchemaFacetPtr facet)
   if (!facet)
     rb_raise(rb_eArgError, "XML::Schema::Facet required!");
 
-  result = Data_Wrap_Struct(cXMLSchemaFacet, NULL, rxml_schema_facet_free, facet);
+  result = TypedData_Wrap_Struct(cXMLSchemaFacet, &rxml_schema_facet_type, facet);
 
   rb_iv_set(result, "@kind", INT2NUM(facet->type));
   rb_iv_set(result, "@value", QNIL_OR_STRING(facet->value));
@@ -35,7 +35,7 @@ static VALUE rxml_schema_facet_node(VALUE self)
 {
   xmlSchemaFacetPtr facet;
 
-  Data_Get_Struct(self, xmlSchemaFacet, facet);
+  TypedData_Get_Struct(self, xmlSchemaFacet, &rxml_schema_facet_type, facet);
 
   return rxml_node_wrap(facet->node);
 }

data/ext/libxml/ruby_xml_schema_type.c

@@ -46,11 +46,11 @@ a group definition, a XML_SCHEMA_EXTRA_QNAMEREF (if a reference),
 
 VALUE cXMLSchemaType;
 
-static void rxml_schema_type_free(xmlSchemaTypePtr xschema_type)
-{
-  xschema_type = NULL;
-  xmlFree(xschema_type);
-}
+static const rb_data_type_t rxml_schema_type_type = {
+  "XML::Schema::Type",
+  {NULL, NULL, NULL},
+  NULL, NULL, 0
+};
 
 VALUE rxml_wrap_schema_type(xmlSchemaTypePtr xtype)
 {
@@ -59,7 +59,7 @@ VALUE rxml_wrap_schema_type(xmlSchemaTypePtr xtype)
   if (!xtype)
     rb_raise(rb_eArgError, "XML::Schema::Type required!");
 
-  result = Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype);
+  result = TypedData_Wrap_Struct(cXMLSchemaType, &rxml_schema_type_type, xtype);
 
   rb_iv_set(result, "@name", QNIL_OR_STRING(xtype->name));
   rb_iv_set(result, "@namespace", QNIL_OR_STRING(xtype->targetNamespace));
@@ -72,7 +72,7 @@ static VALUE rxml_schema_type_base(VALUE self)
 {
   xmlSchemaTypePtr xtype;
 
-  Data_Get_Struct(self, xmlSchemaType, xtype);
+  TypedData_Get_Struct(self, xmlSchemaType, &rxml_schema_type_type, xtype);
 
   return (xtype->baseType != xtype) ? rxml_wrap_schema_type(xtype->baseType) : Qnil;
 }
@@ -81,7 +81,7 @@ static VALUE rxml_schema_type_node(VALUE self)
 {
   xmlSchemaTypePtr xtype;
 
-  Data_Get_Struct(self, xmlSchemaType, xtype);
+  TypedData_Get_Struct(self, xmlSchemaType, &rxml_schema_type_type, xtype);
 
   return (xtype->node != NULL) ? rxml_node_wrap(xtype->node) : Qnil;
 }
@@ -93,7 +93,7 @@ static VALUE rxml_schema_type_facets(VALUE self)
   VALUE result = rb_ary_new();
   VALUE facet;
 
-  Data_Get_Struct(self, xmlSchemaType, xtype);
+  TypedData_Get_Struct(self, xmlSchemaType, &rxml_schema_type_type, xtype);
 
   xfacet = xtype->facets;
 
@@ -112,7 +112,7 @@ static VALUE rxml_schema_type_annot(VALUE self)
   VALUE result = Qnil;
   xmlSchemaTypePtr xtype;
 
-  Data_Get_Struct(self, xmlSchemaType, xtype);
+  TypedData_Get_Struct(self, xmlSchemaType, &rxml_schema_type_type, xtype);
 
   if(xtype != NULL && xtype->annot != NULL && xtype->annot->content != NULL)
   {
@@ -198,7 +198,7 @@ static VALUE rxml_schema_type_elements(VALUE self)
   VALUE result = rb_hash_new();
   xmlSchemaTypePtr xtype;
 
-  Data_Get_Struct(self, xmlSchemaType, xtype);
+  TypedData_Get_Struct(self, xmlSchemaType, &rxml_schema_type_type, xtype);
   rxmlSchemaCollectElements((xmlSchemaParticlePtr) xtype->subtypes, result);
 
   return result;
@@ -212,7 +212,7 @@ static VALUE rxml_schema_type_attributes(VALUE self)
   xmlSchemaItemListPtr xuses;
   int i;
 
-  Data_Get_Struct(self, xmlSchemaType, xtype);
+  TypedData_Get_Struct(self, xmlSchemaType, &rxml_schema_type_type, xtype);
   xuses = xtype->attrUses;
 
   if (xuses != NULL)
@@ -229,13 +229,6 @@ static VALUE rxml_schema_type_attributes(VALUE self)
 
 void rxml_init_schema_type(void)
 {
-  /* Add in infinity support for ruby 1.8.7 */
-  #if !defined(RUBY_VM) && defined(INFINITY)
-  ID infinityId = rb_intern("INFINITY");
-  if (rb_const_defined(rb_cFloat, infinityId) == Qfalse)
-    rb_define_const(rb_cFloat, "INFINITY", rb_float_new(INFINITY));
-  #endif
-
   cXMLSchemaType = rb_define_class_under(cXMLSchema, "Type", rb_cObject);
   rb_undef_alloc_func(cXMLSchemaType);
 

data/ext/libxml/ruby_xml_version.h

@@ -1,9 +1,9 @@
 /* Don't nuke this block!  It is used for automatically updating the
  * versions below. VERSION = string formatting, VERNUM = numbered
  * version for inline testing: increment both or none at all.*/
-#define RUBY_LIBXML_VERSION  "5.0.6"
-#define RUBY_LIBXML_VERNUM   505
-#define RUBY_LIBXML_VER_MAJ   5
+#define RUBY_LIBXML_VERSION  "6.0.0"
+#define RUBY_LIBXML_VERNUM   600
+#define RUBY_LIBXML_VER_MAJ   6
 #define RUBY_LIBXML_VER_MIN   0
-#define RUBY_LIBXML_VER_MIC   6
+#define RUBY_LIBXML_VER_MIC   0
 #define RUBY_LIBXML_VER_PATCH 0

data/ext/libxml/ruby_xml_writer.c

@@ -41,8 +41,9 @@ typedef struct
     int closed;
 } rxml_writer_object;
 
-static void rxml_writer_free(rxml_writer_object* rwo)
+static void rxml_writer_free(void* data)
 {
+    rxml_writer_object* rwo = (rxml_writer_object*)data;
     xmlBufferPtr buffer = rwo->buffer;
 
     rwo->closed = 1;
@@ -56,24 +57,31 @@ static void rxml_writer_free(rxml_writer_object* rwo)
     xfree(rwo);
 }
 
-static void rxml_writer_mark(rxml_writer_object* rwo)
+static void rxml_writer_mark(void* data)
 {
+    rxml_writer_object* rwo = (rxml_writer_object*)data;
     if (!NIL_P(rwo->output))
     {
         rb_gc_mark(rwo->output);
     }
 }
 
+static const rb_data_type_t rxml_writer_data_type = {
+    .wrap_struct_name = "LibXML::XML::Writer",
+    .function = { .dmark = rxml_writer_mark, .dfree = rxml_writer_free },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE rxml_writer_wrap(rxml_writer_object* rwo)
 {
-    return Data_Wrap_Struct(cXMLWriter, rxml_writer_mark, rxml_writer_free, rwo);
+    return TypedData_Wrap_Struct(cXMLWriter, &rxml_writer_data_type, rwo);
 }
 
 static rxml_writer_object* rxml_textwriter_get(VALUE obj)
 {
     rxml_writer_object* rwo;
 
-    Data_Get_Struct(obj, rxml_writer_object, rwo);
+    TypedData_Get_Struct(obj, rxml_writer_object, &rxml_writer_data_type, rwo);
 
     return rwo;
 }
@@ -188,6 +196,7 @@ static VALUE rxml_writer_doc(VALUE klass)
 {
     xmlDocPtr doc;
     rxml_writer_object* rwo;
+    VALUE output, result;
 
     rwo = ALLOC(rxml_writer_object);
     rwo->buffer = NULL;
@@ -199,9 +208,12 @@ static VALUE rxml_writer_doc(VALUE klass)
     {
         rxml_raise(xmlGetLastError());
     }
-    rwo->output = rxml_document_wrap(doc);
+    output = rxml_document_wrap(doc);
+    rwo->output = output;
 
-    return rxml_writer_wrap(rwo);
+    result = rxml_writer_wrap(rwo);
+    RB_GC_GUARD(output);
+    return result;
 }
 
 /* ===== public instance methods ===== */

data/ext/libxml/ruby_xml_xpath.c

@@ -79,7 +79,7 @@
 
 VALUE mXPath;
 
-VALUE rxml_xpath_to_value(xmlXPathContextPtr xctxt, xmlXPathObjectPtr xobject)
+VALUE rxml_xpath_to_value(VALUE document, xmlXPathContextPtr xctxt, xmlXPathObjectPtr xobject)
 {
   VALUE result;
   int type;
@@ -96,7 +96,7 @@ VALUE rxml_xpath_to_value(xmlXPathContextPtr xctxt, xmlXPathObjectPtr xobject)
   switch (type = xobject->type)
   {
     case XPATH_NODESET:
-      result = rxml_xpath_object_wrap(xctxt->doc, xobject);
+      result = rxml_xpath_object_wrap(document, xctxt->doc, xobject);
       break;
     case XPATH_BOOLEAN:
       result = (xobject->boolval != 0) ? Qtrue : Qfalse;

data/ext/libxml/ruby_xml_xpath.h

@@ -9,7 +9,7 @@ extern VALUE mXPath;
 
 void rxml_init_xpath(void);
 
-VALUE rxml_xpath_to_value(xmlXPathContextPtr, xmlXPathObjectPtr);
+VALUE rxml_xpath_to_value(VALUE, xmlXPathContextPtr, xmlXPathObjectPtr);
 xmlXPathObjectPtr rxml_xpath_from_value(VALUE);
 
 #endif

data/ext/libxml/ruby_xml_xpath_context.c

@@ -28,20 +28,39 @@
 
 VALUE cXMLXPathContext;
 
-static void rxml_xpath_context_free(xmlXPathContextPtr ctxt)
+typedef struct rxml_xpath_context
 {
-  xmlXPathFreeContext(ctxt);
+  xmlXPathContextPtr xctxt;
+  VALUE document;
+} rxml_xpath_context;
+
+static void rxml_xpath_context_free(void *data)
+{
+  rxml_xpath_context *wrapper = (rxml_xpath_context *)data;
+  if (wrapper == NULL) return;
+  if (wrapper->xctxt)
+  {
+    xmlXPathFreeContext(wrapper->xctxt);
+  }
+  xfree(wrapper);
 }
 
-static void rxml_xpath_context_mark(xmlXPathContextPtr ctxt)
+static void rxml_xpath_context_mark(void *data)
 {
-  VALUE value = (VALUE)ctxt->doc->_private;
-  rb_gc_mark(value);
+  rxml_xpath_context *wrapper = (rxml_xpath_context *)data;
+  if (wrapper == NULL) return;
+  rb_gc_mark(wrapper->document);
 }
 
+static const rb_data_type_t rxml_xpath_context_data_type = {
+  .wrap_struct_name = "LibXML::XML::XPath::Context",
+  .function = { .dmark = rxml_xpath_context_mark, .dfree = rxml_xpath_context_free },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE rxml_xpath_context_alloc(VALUE klass)
 {
-  return Data_Wrap_Struct(cXMLXPathContext, rxml_xpath_context_mark, rxml_xpath_context_free, NULL);
+  return TypedData_Wrap_Struct(cXMLXPathContext, &rxml_xpath_context_data_type, NULL);
 }
 
 /* call-seq:
@@ -58,14 +77,29 @@ static VALUE rxml_xpath_context_alloc(VALUE klass)
 static VALUE rxml_xpath_context_initialize(VALUE self, VALUE document)
 {
   xmlDocPtr xdoc;
+  rxml_xpath_context *wrapper;
 
   if (rb_obj_is_kind_of(document, cXMLDocument) != Qtrue)
   {
     rb_raise(rb_eTypeError, "Supplied argument must be a document or node.");
   }
 
-  Data_Get_Struct(document, xmlDoc, xdoc);
-  DATA_PTR(self) = xmlXPathNewContext(xdoc);
+  TypedData_Get_Struct(document, xmlDoc, &rxml_document_data_type, xdoc);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+
+  if (wrapper == NULL)
+  {
+    wrapper = ALLOC(rxml_xpath_context);
+    wrapper->xctxt = NULL;
+    wrapper->document = document;
+    RTYPEDDATA_DATA(self) = wrapper;
+  }
+  else if (wrapper->xctxt)
+  {
+    xmlXPathFreeContext(wrapper->xctxt);
+  }
+
+  wrapper->xctxt = xmlXPathNewContext(xdoc);
 
   return self;
 }
@@ -78,12 +112,10 @@ static VALUE rxml_xpath_context_initialize(VALUE self, VALUE document)
  */
 static VALUE rxml_xpath_context_doc(VALUE self)
 {
-  xmlDocPtr xdoc = NULL;
-  xmlXPathContextPtr ctxt;
-  Data_Get_Struct(self, xmlXPathContext, ctxt);
-  
-  xdoc = ctxt->doc;
-  return rxml_document_wrap(xdoc);
+  rxml_xpath_context *wrapper;
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  if (wrapper == NULL) return Qnil;
+  return wrapper->document;
 }
 
 /*
@@ -97,8 +129,10 @@ static VALUE rxml_xpath_context_doc(VALUE self)
  */
 static VALUE rxml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri)
 {
+  rxml_xpath_context *wrapper;
   xmlXPathContextPtr ctxt;
-  Data_Get_Struct(self, xmlXPathContext, ctxt);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  ctxt = wrapper->xctxt;
 
   /* Prefix could be a symbol. */
   prefix = rb_obj_as_string(prefix);
@@ -128,21 +162,23 @@ static VALUE rxml_xpath_context_register_namespace(VALUE self, VALUE prefix, VAL
 static VALUE rxml_xpath_context_register_namespaces_from_node(VALUE self,
     VALUE node)
 {
+  rxml_xpath_context *wrapper;
   xmlXPathContextPtr xctxt;
   xmlNodePtr xnode;
   xmlNsPtr *xnsArr;
 
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  xctxt = wrapper->xctxt;
 
   if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
   {
     xmlDocPtr xdoc;
-    Data_Get_Struct(node, xmlDoc, xdoc);
+    TypedData_Get_Struct(node, xmlDoc, &rxml_document_data_type, xdoc);
     xnode = xmlDocGetRootElement(xdoc);
   }
   else if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
   {
-    Data_Get_Struct(node, xmlNode, xnode);
+    TypedData_Get_Struct(node, xmlNode, &rxml_node_data_type, xnode);
   }
   else
   {
@@ -198,9 +234,11 @@ static VALUE rxml_xpath_context_register_namespaces(VALUE self, VALUE nslist)
   char *cp;
   long i;
   VALUE rprefix, ruri;
+  rxml_xpath_context *wrapper;
   xmlXPathContextPtr xctxt;
 
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  xctxt = wrapper->xctxt;
 
   /* Need to loop through the 2nd argument and iterate through the
    * list of namespaces that we want to allow */
@@ -249,11 +287,13 @@ static VALUE rxml_xpath_context_register_namespaces(VALUE self, VALUE nslist)
  */
 static VALUE rxml_xpath_context_node_set(VALUE self, VALUE node)
 {
+  rxml_xpath_context *wrapper;
   xmlXPathContextPtr xctxt;
   xmlNodePtr xnode;
 
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
-  Data_Get_Struct(node, xmlNode, xnode);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  xctxt = wrapper->xctxt;
+  TypedData_Get_Struct(node, xmlNode, &rxml_node_data_type, xnode);
   xctxt->node = xnode;
   return node;
 }
@@ -268,11 +308,13 @@ static VALUE rxml_xpath_context_node_set(VALUE self, VALUE node)
  */
 static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
 {
+  rxml_xpath_context *wrapper;
   xmlXPathContextPtr xctxt;
   xmlXPathObjectPtr xobject;
   xmlXPathCompExprPtr xcompexpr;
 
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  xctxt = wrapper->xctxt;
 
   if (TYPE(xpath_expr) == T_STRING)
   {
@@ -281,7 +323,7 @@ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
   }
   else if (rb_obj_is_kind_of(xpath_expr, cXMLXPathExpression))
   {
-    Data_Get_Struct(xpath_expr, xmlXPathCompExpr, xcompexpr);
+    TypedData_Get_Struct(xpath_expr, xmlXPathCompExpr, &rxml_xpath_expression_data_type, xcompexpr);
     xobject = xmlXPathCompiledEval(xcompexpr, xctxt);
   }
   else
@@ -290,7 +332,7 @@ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
         "Argument should be an instance of a String or XPath::Expression");
   }
 
-  return rxml_xpath_to_value(xctxt, xobject);
+  return rxml_xpath_to_value(wrapper->document, xctxt, xobject);
 }
 
 #if LIBXML_VERSION >= 20626
@@ -308,11 +350,13 @@ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
 static VALUE
 rxml_xpath_context_enable_cache(int argc,  VALUE *argv, VALUE self)
 {
+  rxml_xpath_context *wrapper;
   xmlXPathContextPtr xctxt;
   VALUE size;
   int value = -1;
 
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  xctxt = wrapper->xctxt;
 
   if (rb_scan_args(argc, argv, "01", &size) == 1)
   {
@@ -334,8 +378,10 @@ rxml_xpath_context_enable_cache(int argc,  VALUE *argv, VALUE self)
 static VALUE
 rxml_xpath_context_disable_cache(VALUE self)
 {
+  rxml_xpath_context *wrapper;
   xmlXPathContextPtr xctxt;
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  TypedData_Get_Struct(self, rxml_xpath_context, &rxml_xpath_context_data_type, wrapper);
+  xctxt = wrapper->xctxt;
 
   if (xmlXPathContextSetCache(xctxt, 0, 0, 0) == -1)
     rxml_raise(xmlGetLastError());