nokogiri 1.14.5-aarch64-linux → 1.15.0-aarch64-linux

data/ext/nokogiri/xml_reader.c

@@ -3,11 +3,20 @@
 VALUE cNokogiriXmlReader;
 
 static void
-dealloc(xmlTextReaderPtr reader)
+xml_reader_deallocate(void *data)
 {
+  xmlTextReaderPtr reader = data;
   xmlFreeTextReader(reader);
 }
 
+static const rb_data_type_t xml_reader_type = {
+  .wrap_struct_name = "Nokogiri::XML::Reader",
+  .function = {
+    .dfree = xml_reader_deallocate,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
 static int
 has_attributes(xmlTextReaderPtr reader)
 {
@@ -69,7 +78,7 @@ default_eh(VALUE self)
   xmlTextReaderPtr reader;
   int eh;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   eh = xmlTextReaderIsDefault(reader);
   if (eh == 0) { return Qfalse; }
   if (eh == 1) { return Qtrue; }
@@ -89,7 +98,7 @@ value_eh(VALUE self)
   xmlTextReaderPtr reader;
   int eh;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   eh = xmlTextReaderHasValue(reader);
   if (eh == 0) { return Qfalse; }
   if (eh == 1) { return Qtrue; }
@@ -109,7 +118,7 @@ attributes_eh(VALUE self)
   xmlTextReaderPtr reader;
   int eh;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   eh = has_attributes(reader);
   if (eh == 0) { return Qfalse; }
   if (eh == 1) { return Qtrue; }
@@ -131,7 +140,7 @@ rb_xml_reader_namespaces(VALUE rb_reader)
   xmlNodePtr c_node;
   VALUE rb_errors;
 
-  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+  TypedData_Get_Struct(rb_reader, xmlTextReader, &xml_reader_type, c_reader);
 
   if (! has_attributes(c_reader)) {
     return rb_namespaces ;
@@ -178,7 +187,7 @@ rb_xml_reader_attribute_nodes(VALUE rb_reader)
   // After removal, we can also remove all the "node_has_a_document" special handling from xml_node.c
   NOKO_WARN_DEPRECATION("Reader#attribute_nodes is deprecated and will be removed in a future version of Nokogiri. Please use Reader#attribute_hash instead.");
 
-  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+  TypedData_Get_Struct(rb_reader, xmlTextReader, &xml_reader_type, c_reader);
 
   if (! has_attributes(c_reader)) {
     return rb_ary_new() ;
@@ -215,7 +224,7 @@ rb_xml_reader_attribute_hash(VALUE rb_reader)
   xmlAttrPtr c_property;
   VALUE rb_errors;
 
-  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+  TypedData_Get_Struct(rb_reader, xmlTextReader, &xml_reader_type, c_reader);
 
   if (!has_attributes(c_reader)) {
     return rb_attributes;
@@ -268,7 +277,7 @@ attribute_at(VALUE self, VALUE index)
   xmlChar *value;
   VALUE rb_value;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
 
   if (NIL_P(index)) { return Qnil; }
   index = rb_Integer(index);
@@ -297,7 +306,7 @@ reader_attribute(VALUE self, VALUE name)
   xmlChar *value ;
   VALUE rb_value;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
 
   if (NIL_P(name)) { return Qnil; }
   name = StringValue(name) ;
@@ -322,7 +331,7 @@ attribute_count(VALUE self)
   xmlTextReaderPtr reader;
   int count;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   count = xmlTextReaderAttributeCount(reader);
   if (count == -1) { return Qnil; }
 
@@ -341,7 +350,7 @@ depth(VALUE self)
   xmlTextReaderPtr reader;
   int depth;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   depth = xmlTextReaderDepth(reader);
   if (depth == -1) { return Qnil; }
 
@@ -360,7 +369,7 @@ xml_version(VALUE self)
   xmlTextReaderPtr reader;
   const char *version;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   version = (const char *)xmlTextReaderConstXmlVersion(reader);
   if (version == NULL) { return Qnil; }
 
@@ -379,7 +388,7 @@ lang(VALUE self)
   xmlTextReaderPtr reader;
   const char *lang;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   lang = (const char *)xmlTextReaderConstXmlLang(reader);
   if (lang == NULL) { return Qnil; }
 
@@ -398,7 +407,7 @@ value(VALUE self)
   xmlTextReaderPtr reader;
   const char *value;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   value = (const char *)xmlTextReaderConstValue(reader);
   if (value == NULL) { return Qnil; }
 
@@ -417,7 +426,7 @@ prefix(VALUE self)
   xmlTextReaderPtr reader;
   const char *prefix;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   prefix = (const char *)xmlTextReaderConstPrefix(reader);
   if (prefix == NULL) { return Qnil; }
 
@@ -436,7 +445,7 @@ namespace_uri(VALUE self)
   xmlTextReaderPtr reader;
   const char *uri;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   uri = (const char *)xmlTextReaderConstNamespaceUri(reader);
   if (uri == NULL) { return Qnil; }
 
@@ -455,7 +464,7 @@ local_name(VALUE self)
   xmlTextReaderPtr reader;
   const char *name;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   name = (const char *)xmlTextReaderConstLocalName(reader);
   if (name == NULL) { return Qnil; }
 
@@ -474,7 +483,7 @@ name(VALUE self)
   xmlTextReaderPtr reader;
   const char *name;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   name = (const char *)xmlTextReaderConstName(reader);
   if (name == NULL) { return Qnil; }
 
@@ -494,7 +503,7 @@ rb_xml_reader_base_uri(VALUE rb_reader)
   xmlTextReaderPtr c_reader;
   xmlChar *c_base_uri;
 
-  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+  TypedData_Get_Struct(rb_reader, xmlTextReader, &xml_reader_type, c_reader);
 
   c_base_uri = xmlTextReaderBaseUri(c_reader);
   if (c_base_uri == NULL) {
@@ -517,7 +526,7 @@ static VALUE
 state(VALUE self)
 {
   xmlTextReaderPtr reader;
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   return INT2NUM(xmlTextReaderReadState(reader));
 }
 
@@ -531,7 +540,7 @@ static VALUE
 node_type(VALUE self)
 {
   xmlTextReaderPtr reader;
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
   return INT2NUM(xmlTextReaderNodeType(reader));
 }
 
@@ -549,7 +558,7 @@ read_more(VALUE self)
   VALUE error_list;
   int ret;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
 
   error_list = rb_funcall(self, rb_intern("errors"), 0);
 
@@ -584,7 +593,7 @@ inner_xml(VALUE self)
   xmlChar *value;
   VALUE str;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
 
   value = xmlTextReaderReadInnerXml(reader);
 
@@ -611,7 +620,7 @@ outer_xml(VALUE self)
   xmlChar *value;
   VALUE str = Qnil;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
 
   value = xmlTextReaderReadOuterXml(reader);
 
@@ -658,7 +667,7 @@ from_memory(int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eRuntimeError, "couldn't create a parser");
   }
 
-  rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
+  rb_reader = TypedData_Wrap_Struct(klass, &xml_reader_type, reader);
   args[0] = rb_buffer;
   args[1] = rb_url;
   args[2] = encoding;
@@ -704,7 +713,7 @@ from_io(int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eRuntimeError, "couldn't create a parser");
   }
 
-  rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
+  rb_reader = TypedData_Wrap_Struct(klass, &xml_reader_type, reader);
   args[0] = rb_io;
   args[1] = rb_url;
   args[2] = encoding;
@@ -724,7 +733,7 @@ empty_element_p(VALUE self)
 {
   xmlTextReaderPtr reader;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
 
   if (xmlTextReaderIsEmptyElement(reader)) {
     return Qtrue;
@@ -745,7 +754,7 @@ rb_xml_reader_encoding(VALUE rb_reader)
     return constructor_encoding;
   }
 
-  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+  TypedData_Get_Struct(rb_reader, xmlTextReader, &xml_reader_type, c_reader);
   parser_encoding = (const char *)xmlTextReaderConstEncoding(c_reader);
   if (parser_encoding == NULL) { return Qnil; }
   return NOKOGIRI_STR_NEW2(parser_encoding);

data/ext/nokogiri/xml_relax_ng.c

@@ -3,11 +3,20 @@
 VALUE cNokogiriXmlRelaxNG;
 
 static void
-dealloc(xmlRelaxNGPtr schema)
+xml_relax_ng_deallocate(void *data)
 {
+  xmlRelaxNGPtr schema = data;
   xmlRelaxNGFree(schema);
 }
 
+static const rb_data_type_t xml_relax_ng_type = {
+  .wrap_struct_name = "Nokogiri::XML::RelaxNG",
+  .function = {
+    .dfree = xml_relax_ng_deallocate,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
 /*
  * call-seq:
  *  validate_document(document)
@@ -22,8 +31,8 @@ validate_document(VALUE self, VALUE document)
   VALUE errors;
   xmlRelaxNGValidCtxtPtr valid_ctxt;
 
-  Data_Get_Struct(self, xmlRelaxNG, schema);
-  Data_Get_Struct(document, xmlDoc, doc);
+  TypedData_Get_Struct(self, xmlRelaxNG, &xml_relax_ng_type, schema);
+  doc = noko_xml_document_unwrap(document);
 
   errors = rb_ary_new();
 
@@ -49,47 +58,41 @@ validate_document(VALUE self, VALUE document)
   return errors;
 }
 
-/*
- * call-seq:
- *  read_memory(string)
- *
- * Create a new RelaxNG from the contents of +string+
- */
 static VALUE
-read_memory(int argc, VALUE *argv, VALUE klass)
+xml_relax_ng_parse_schema(
+  VALUE klass,
+  xmlRelaxNGParserCtxtPtr c_parser_context,
+  VALUE rb_parse_options
+)
 {
-  VALUE content;
-  VALUE parse_options;
-  xmlRelaxNGParserCtxtPtr ctx;
-  xmlRelaxNGPtr schema;
-  VALUE errors;
+  VALUE rb_errors;
   VALUE rb_schema;
-  int scanned_args = 0;
+  xmlRelaxNGPtr c_schema;
 
-  scanned_args = rb_scan_args(argc, argv, "11", &content, &parse_options);
-  if (scanned_args == 1) {
-    parse_options = rb_const_get_at(rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  if (NIL_P(rb_parse_options)) {
+    rb_parse_options = rb_const_get_at(
+                         rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")),
+                         rb_intern("DEFAULT_SCHEMA")
+                       );
   }
 
-  ctx = xmlRelaxNGNewMemParserCtxt((const char *)StringValuePtr(content), (int)RSTRING_LEN(content));
-
-  errors = rb_ary_new();
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+  rb_errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)rb_errors, Nokogiri_error_array_pusher);
 
 #ifdef HAVE_XMLRELAXNGSETPARSERSTRUCTUREDERRORS
   xmlRelaxNGSetParserStructuredErrors(
-    ctx,
+    c_parser_context,
     Nokogiri_error_array_pusher,
-    (void *)errors
+    (void *)rb_errors
   );
 #endif
 
-  schema = xmlRelaxNGParse(ctx);
+  c_schema = xmlRelaxNGParse(c_parser_context);
 
   xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlRelaxNGFreeParserCtxt(ctx);
+  xmlRelaxNGFreeParserCtxt(c_parser_context);
 
-  if (NULL == schema) {
+  if (NULL == c_schema) {
     xmlErrorPtr error = xmlGetLastError();
     if (error) {
       Nokogiri_error_raise(NULL, error);
@@ -100,74 +103,58 @@ read_memory(int argc, VALUE *argv, VALUE klass)
     return Qnil;
   }
 
-  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
-  rb_iv_set(rb_schema, "@errors", errors);
-  rb_iv_set(rb_schema, "@parse_options", parse_options);
+  rb_schema = TypedData_Wrap_Struct(klass, &xml_relax_ng_type, c_schema);
+  rb_iv_set(rb_schema, "@errors", rb_errors);
+  rb_iv_set(rb_schema, "@parse_options", rb_parse_options);
 
   return rb_schema;
 }
 
 /*
  * call-seq:
- *  from_document(doc)
+ *  read_memory(string)
  *
- * Create a new RelaxNG schema from the Nokogiri::XML::Document +doc+
+ * Create a new RelaxNG from the contents of +string+
  */
 static VALUE
-from_document(int argc, VALUE *argv, VALUE klass)
+read_memory(int argc, VALUE *argv, VALUE klass)
 {
-  VALUE document;
-  VALUE parse_options;
-  xmlDocPtr doc;
-  xmlRelaxNGParserCtxtPtr ctx;
-  xmlRelaxNGPtr schema;
-  VALUE errors;
-  VALUE rb_schema;
-  int scanned_args = 0;
+  VALUE rb_content;
+  VALUE rb_parse_options;
+  xmlRelaxNGParserCtxtPtr c_parser_context;
 
-  scanned_args = rb_scan_args(argc, argv, "11", &document, &parse_options);
+  rb_scan_args(argc, argv, "11", &rb_content, &rb_parse_options);
 
-  Data_Get_Struct(document, xmlDoc, doc);
-  doc = doc->doc; /* In case someone passes us a node. ugh. */
-
-  if (scanned_args == 1) {
-    parse_options = rb_const_get_at(rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
-  }
-
-  ctx = xmlRelaxNGNewDocParserCtxt(doc);
-
-  errors = rb_ary_new();
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+  c_parser_context = xmlRelaxNGNewMemParserCtxt(
+                       (const char *)StringValuePtr(rb_content),
+                       (int)RSTRING_LEN(rb_content)
+                     );
 
-#ifdef HAVE_XMLRELAXNGSETPARSERSTRUCTUREDERRORS
-  xmlRelaxNGSetParserStructuredErrors(
-    ctx,
-    Nokogiri_error_array_pusher,
-    (void *)errors
-  );
-#endif
-
-  schema = xmlRelaxNGParse(ctx);
+  return xml_relax_ng_parse_schema(klass, c_parser_context, rb_parse_options);
+}
 
-  xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlRelaxNGFreeParserCtxt(ctx);
+/*
+ * call-seq:
+ *  from_document(doc)
+ *
+ * Create a new RelaxNG schema from the Nokogiri::XML::Document +doc+
+ */
+static VALUE
+from_document(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE rb_document;
+  VALUE rb_parse_options;
+  xmlDocPtr c_document;
+  xmlRelaxNGParserCtxtPtr c_parser_context;
 
-  if (NULL == schema) {
-    xmlErrorPtr error = xmlGetLastError();
-    if (error) {
-      Nokogiri_error_raise(NULL, error);
-    } else {
-      rb_raise(rb_eRuntimeError, "Could not parse document");
-    }
+  rb_scan_args(argc, argv, "11", &rb_document, &rb_parse_options);
 
-    return Qnil;
-  }
+  c_document = noko_xml_document_unwrap(rb_document);
+  c_document = c_document->doc; /* In case someone passes us a node. ugh. */
 
-  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
-  rb_iv_set(rb_schema, "@errors", errors);
-  rb_iv_set(rb_schema, "@parse_options", parse_options);
+  c_parser_context = xmlRelaxNGNewDocParserCtxt(c_document);
 
-  return rb_schema;
+  return xml_relax_ng_parse_schema(klass, c_parser_context, rb_parse_options);
 }
 
 void

data/ext/nokogiri/xml_sax_parser.c

@@ -265,16 +265,27 @@ processing_instruction(void *ctx, const xmlChar *name, const xmlChar *content)
             );
 }
 
-static void
-deallocate(xmlSAXHandlerPtr handler)
+static size_t
+memsize(const void *data)
 {
-  ruby_xfree(handler);
+  return sizeof(xmlSAXHandler);
 }
 
+/* Used by Nokogiri::XML::SAX::Parser and Nokogiri::HTML::SAX::Parser */
+static const rb_data_type_t noko_sax_handler_type = {
+  .wrap_struct_name = "Nokogiri::SAXHandler",
+  .function = {
+    .dfree = RUBY_TYPED_DEFAULT_FREE,
+    .dsize = memsize
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
 static VALUE
 allocate(VALUE klass)
 {
-  xmlSAXHandlerPtr handler = ruby_xcalloc((size_t)1, sizeof(xmlSAXHandler));
+  xmlSAXHandlerPtr handler;
+  VALUE self = TypedData_Make_Struct(klass, xmlSAXHandler, &noko_sax_handler_type, handler);
 
   handler->startDocument = start_document;
   handler->endDocument = end_document;
@@ -290,7 +301,15 @@ allocate(VALUE klass)
   handler->processingInstruction = processing_instruction;
   handler->initialized = XML_SAX2_MAGIC;
 
-  return Data_Wrap_Struct(klass, NULL, deallocate, handler);
+  return self;
+}
+
+xmlSAXHandlerPtr
+noko_sax_handler_unwrap(VALUE rb_sax_handler)
+{
+  xmlSAXHandlerPtr c_sax_handler;
+  TypedData_Get_Struct(rb_sax_handler, xmlSAXHandler, &noko_sax_handler_type, c_sax_handler);
+  return c_sax_handler;
 }
 
 void

data/ext/nokogiri/xml_sax_parser_context.c

@@ -5,12 +5,40 @@ VALUE cNokogiriXmlSaxParserContext ;
 static ID id_read;
 
 static void
-deallocate(xmlParserCtxtPtr ctxt)
+xml_sax_parser_context_free(void *data)
 {
+  xmlParserCtxtPtr ctxt = data;
   ctxt->sax = NULL;
   xmlFreeParserCtxt(ctxt);
 }
 
+/*
+ *  note that htmlParserCtxtPtr == xmlParserCtxtPtr and xmlFreeParserCtxt() == htmlFreeParserCtxt()
+ *  so we use this type for both XML::SAX::ParserContext and HTML::SAX::ParserContext
+ */
+static const rb_data_type_t xml_sax_parser_context_type = {
+  .wrap_struct_name = "Nokogiri::XML::SAX::ParserContext",
+  .function = {
+    .dfree = xml_sax_parser_context_free,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+xmlParserCtxtPtr
+noko_xml_sax_parser_context_unwrap(VALUE rb_context)
+{
+  xmlParserCtxtPtr c_context;
+  TypedData_Get_Struct(rb_context, xmlParserCtxt, &xml_sax_parser_context_type, c_context);
+  return c_context;
+}
+
+VALUE
+noko_xml_sax_parser_context_wrap(VALUE klass, xmlParserCtxtPtr c_context)
+{
+  return TypedData_Wrap_Struct(klass, &xml_sax_parser_context_type, c_context);
+}
+
+
 /*
  * call-seq:
  *  parse_io(io, encoding)
@@ -36,7 +64,7 @@ parse_io(VALUE klass, VALUE io, VALUE encoding)
     ctxt->sax = NULL;
   }
 
-  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+  return noko_xml_sax_parser_context_wrap(klass, ctxt);
 }
 
 /*
@@ -49,7 +77,13 @@ static VALUE
 parse_file(VALUE klass, VALUE filename)
 {
   xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(StringValueCStr(filename));
-  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+
+  if (ctxt->sax) {
+    xmlFree(ctxt->sax);
+    ctxt->sax = NULL;
+  }
+
+  return noko_xml_sax_parser_context_wrap(klass, ctxt);
 }
 
 /*
@@ -76,7 +110,7 @@ parse_memory(VALUE klass, VALUE data)
     ctxt->sax = NULL;
   }
 
-  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+  return noko_xml_sax_parser_context_wrap(klass, ctxt);
 }
 
 static VALUE
@@ -116,13 +150,8 @@ parse_with(VALUE self, VALUE sax_handler)
     rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
   }
 
-  Data_Get_Struct(self, xmlParserCtxt, ctxt);
-  Data_Get_Struct(sax_handler, xmlSAXHandler, sax);
-
-  /* Free the sax handler since we'll assign our own */
-  if (ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) {
-    xmlFree(ctxt->sax);
-  }
+  ctxt = noko_xml_sax_parser_context_unwrap(self);
+  sax = noko_sax_handler_unwrap(sax_handler);
 
   ctxt->sax = sax;
   ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
@@ -144,8 +173,7 @@ parse_with(VALUE self, VALUE sax_handler)
 static VALUE
 set_replace_entities(VALUE self, VALUE value)
 {
-  xmlParserCtxtPtr ctxt;
-  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
 
   if (Qfalse == value) {
     ctxt->replaceEntities = 0;
@@ -166,8 +194,7 @@ set_replace_entities(VALUE self, VALUE value)
 static VALUE
 get_replace_entities(VALUE self)
 {
-  xmlParserCtxtPtr ctxt;
-  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
 
   if (0 == ctxt->replaceEntities) {
     return Qfalse;
@@ -184,10 +211,8 @@ get_replace_entities(VALUE self)
 static VALUE
 line(VALUE self)
 {
-  xmlParserCtxtPtr ctxt;
   xmlParserInputPtr io;
-
-  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
 
   io = ctxt->input;
   if (io) {
@@ -205,11 +230,9 @@ line(VALUE self)
 static VALUE
 column(VALUE self)
 {
-  xmlParserCtxtPtr ctxt;
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
   xmlParserInputPtr io;
 
-  Data_Get_Struct(self, xmlParserCtxt, ctxt);
-
   io = ctxt->input;
   if (io) {
     return INT2NUM(io->col);
@@ -228,8 +251,7 @@ column(VALUE self)
 static VALUE
 set_recovery(VALUE self, VALUE value)
 {
-  xmlParserCtxtPtr ctxt;
-  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
 
   if (value == Qfalse) {
     ctxt->recovery = 0;
@@ -250,8 +272,7 @@ set_recovery(VALUE self, VALUE value)
 static VALUE
 get_recovery(VALUE self)
 {
-  xmlParserCtxtPtr ctxt;
-  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
 
   if (ctxt->recovery == 0) {
     return Qfalse;