nokogiri 1.14.2 → 1.16.6

data/ext/nokogiri/xml_reader.c

@@ -3,11 +3,26 @@
 VALUE cNokogiriXmlReader;
 
 static void
-dealloc(xmlTextReaderPtr reader)
+xml_reader_deallocate(void *data)
 {
+  // free the document separately because we _may_ have triggered preservation by calling
+  // xmlTextReaderCurrentDoc during a read_more.
+  xmlTextReaderPtr reader = data;
+  xmlDocPtr doc = xmlTextReaderCurrentDoc(reader);
   xmlFreeTextReader(reader);
+  if (doc) {
+    xmlFreeDoc(doc);
+  }
 }
 
+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 +84,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 +104,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 +124,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 +146,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 ;
@@ -157,48 +172,6 @@ rb_xml_reader_namespaces(VALUE rb_reader)
   return rb_namespaces ;
 }
 
-/*
-  :call-seq: attribute_nodes() → Array<Nokogiri::XML::Attr>
-
-  Get the attributes of the current node as an Array of XML:Attr
-
-  ⚠ This method is deprecated and unsafe to use. It will be removed in a future version of Nokogiri.
-
-  See related: #attribute_hash, #attributes
- */
-static VALUE
-rb_xml_reader_attribute_nodes(VALUE rb_reader)
-{
-  xmlTextReaderPtr c_reader;
-  xmlNodePtr c_node;
-  VALUE attr_nodes;
-  int j;
-
-  // TODO: deprecated, remove in Nokogiri v1.15, see https://github.com/sparklemotion/nokogiri/issues/2598
-  // 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);
-
-  if (! has_attributes(c_reader)) {
-    return rb_ary_new() ;
-  }
-
-  c_node = xmlTextReaderExpand(c_reader);
-  if (c_node == NULL) {
-    return Qnil;
-  }
-
-  attr_nodes = noko_xml_node_attrs(c_node);
-
-  /* ensure that the Reader won't be GCed as long as a node is referenced */
-  for (j = 0 ; j < RARRAY_LEN(attr_nodes) ; j++) {
-    rb_iv_set(rb_ary_entry(attr_nodes, j), "@reader", rb_reader);
-  }
-
-  return attr_nodes;
-}
-
 /*
   :call-seq: attribute_hash() → Hash<String ⇒ String>
 
@@ -215,7 +188,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 +241,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 +270,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 +295,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 +314,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 +333,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 +352,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 +371,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 +390,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 +409,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 +428,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 +447,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 +467,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 +490,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 +504,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));
 }
 
@@ -545,11 +518,12 @@ static VALUE
 read_more(VALUE self)
 {
   xmlTextReaderPtr reader;
-  xmlErrorPtr error;
+  xmlErrorConstPtr error;
   VALUE error_list;
   int ret;
+  xmlDocPtr c_document;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
+  TypedData_Get_Struct(self, xmlTextReader, &xml_reader_type, reader);
 
   error_list = rb_funcall(self, rb_intern("errors"), 0);
 
@@ -557,6 +531,17 @@ read_more(VALUE self)
   ret = xmlTextReaderRead(reader);
   xmlSetStructuredErrorFunc(NULL, NULL);
 
+  c_document = xmlTextReaderCurrentDoc(reader);
+  if (c_document && c_document->encoding == NULL) {
+    VALUE constructor_encoding = rb_iv_get(self, "@encoding");
+    if (RTEST(constructor_encoding)) {
+      c_document->encoding = xmlStrdup(BAD_CAST StringValueCStr(constructor_encoding));
+    } else {
+      rb_iv_set(self, "@encoding", NOKOGIRI_STR_NEW2("UTF-8"));
+      c_document->encoding = xmlStrdup(BAD_CAST "UTF-8");
+    }
+  }
+
   if (ret == 1) { return self; }
   if (ret == 0) { return Qnil; }
 
@@ -584,7 +569,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 +596,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 +643,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 +689,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 +709,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;
@@ -740,15 +725,18 @@ rb_xml_reader_encoding(VALUE rb_reader)
   const char *parser_encoding;
   VALUE constructor_encoding;
 
+  TypedData_Get_Struct(rb_reader, xmlTextReader, &xml_reader_type, c_reader);
+  parser_encoding = (const char *)xmlTextReaderConstEncoding(c_reader);
+  if (parser_encoding) {
+    return NOKOGIRI_STR_NEW2(parser_encoding);
+  }
+
   constructor_encoding = rb_iv_get(rb_reader, "@encoding");
   if (RTEST(constructor_encoding)) {
     return constructor_encoding;
   }
 
-  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
-  parser_encoding = (const char *)xmlTextReaderConstEncoding(c_reader);
-  if (parser_encoding == NULL) { return Qnil; }
-  return NOKOGIRI_STR_NEW2(parser_encoding);
+  return Qnil;
 }
 
 void
@@ -769,7 +757,6 @@ noko_init_xml_reader(void)
   rb_define_method(cNokogiriXmlReader, "attribute", reader_attribute, 1);
   rb_define_method(cNokogiriXmlReader, "attribute_at", attribute_at, 1);
   rb_define_method(cNokogiriXmlReader, "attribute_count", attribute_count, 0);
-  rb_define_method(cNokogiriXmlReader, "attribute_nodes", rb_xml_reader_attribute_nodes, 0);
   rb_define_method(cNokogiriXmlReader, "attribute_hash", rb_xml_reader_attribute_hash, 0);
   rb_define_method(cNokogiriXmlReader, "attributes?", attributes_eh, 0);
   rb_define_method(cNokogiriXmlReader, "base_uri", rb_xml_reader_base_uri, 0);

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,48 +58,42 @@ 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) {
-    xmlErrorPtr error = xmlGetLastError();
+  if (NULL == c_schema) {
+    xmlErrorConstPtr error = xmlGetLastError();
     if (error) {
       Nokogiri_error_raise(NULL, error);
     } else {
@@ -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;
-
-  scanned_args = rb_scan_args(argc, argv, "11", &document, &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"));
-  }
+  VALUE rb_content;
+  VALUE rb_parse_options;
+  xmlRelaxNGParserCtxtPtr c_parser_context;
 
-  ctx = xmlRelaxNGNewDocParserCtxt(doc);
+  rb_scan_args(argc, argv, "11", &rb_content, &rb_parse_options);
 
-  errors = rb_ary_new();
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
-
-#ifdef HAVE_XMLRELAXNGSETPARSERSTRUCTUREDERRORS
-  xmlRelaxNGSetParserStructuredErrors(
-    ctx,
-    Nokogiri_error_array_pusher,
-    (void *)errors
-  );
-#endif
+  c_parser_context = xmlRelaxNGNewMemParserCtxt(
+                       (const char *)StringValuePtr(rb_content),
+                       (int)RSTRING_LEN(rb_content)
+                     );
 
-  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