Nokogiri_precompiled_aarch64_dedshit 1.14.5

data/ext/nokogiri/libxml2_backwards_compat.c

@@ -0,0 +1,121 @@
+#ifndef HAVE_XMLFIRSTELEMENTCHILD
+#include <nokogiri.h>
+/**
+ * xmlFirstElementChild:
+ * @parent: the parent node
+ *
+ * Finds the first child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the first element child or NULL if not available
+ */
+xmlNodePtr
+xmlFirstElementChild(xmlNodePtr parent)
+{
+  xmlNodePtr cur = NULL;
+
+  if (parent == NULL) {
+    return (NULL);
+  }
+  switch (parent->type) {
+    case XML_ELEMENT_NODE:
+    case XML_ENTITY_NODE:
+    case XML_DOCUMENT_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      cur = parent->children;
+      break;
+    default:
+      return (NULL);
+  }
+  while (cur != NULL) {
+    if (cur->type == XML_ELEMENT_NODE) {
+      return (cur);
+    }
+    cur = cur->next;
+  }
+  return (NULL);
+}
+
+/**
+ * xmlNextElementSibling:
+ * @node: the current node
+ *
+ * Finds the first closest next sibling of the node which is an
+ * element node.
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the next element sibling or NULL if not available
+ */
+xmlNodePtr
+xmlNextElementSibling(xmlNodePtr node)
+{
+  if (node == NULL) {
+    return (NULL);
+  }
+  switch (node->type) {
+    case XML_ELEMENT_NODE:
+    case XML_TEXT_NODE:
+    case XML_CDATA_SECTION_NODE:
+    case XML_ENTITY_REF_NODE:
+    case XML_ENTITY_NODE:
+    case XML_PI_NODE:
+    case XML_COMMENT_NODE:
+    case XML_DTD_NODE:
+    case XML_XINCLUDE_START:
+    case XML_XINCLUDE_END:
+      node = node->next;
+      break;
+    default:
+      return (NULL);
+  }
+  while (node != NULL) {
+    if (node->type == XML_ELEMENT_NODE) {
+      return (node);
+    }
+    node = node->next;
+  }
+  return (NULL);
+}
+
+/**
+ * xmlLastElementChild:
+ * @parent: the parent node
+ *
+ * Finds the last child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the last element child or NULL if not available
+ */
+xmlNodePtr
+xmlLastElementChild(xmlNodePtr parent)
+{
+  xmlNodePtr cur = NULL;
+
+  if (parent == NULL) {
+    return (NULL);
+  }
+  switch (parent->type) {
+    case XML_ELEMENT_NODE:
+    case XML_ENTITY_NODE:
+    case XML_DOCUMENT_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      cur = parent->last;
+      break;
+    default:
+      return (NULL);
+  }
+  while (cur != NULL) {
+    if (cur->type == XML_ELEMENT_NODE) {
+      return (cur);
+    }
+    cur = cur->prev;
+  }
+  return (NULL);
+}
+#endif

data/ext/nokogiri/nokogiri.c

@@ -0,0 +1,265 @@
+#include <nokogiri.h>
+
+VALUE mNokogiri ;
+VALUE mNokogiriGumbo ;
+VALUE mNokogiriHtml4 ;
+VALUE mNokogiriHtml4Sax ;
+VALUE mNokogiriHtml5 ;
+VALUE mNokogiriXml ;
+VALUE mNokogiriXmlSax ;
+VALUE mNokogiriXmlXpath ;
+VALUE mNokogiriXslt ;
+
+VALUE cNokogiriSyntaxError;
+VALUE cNokogiriXmlCharacterData;
+VALUE cNokogiriXmlElement;
+VALUE cNokogiriXmlXpathSyntaxError;
+
+void noko_init_xml_attr(void);
+void noko_init_xml_attribute_decl(void);
+void noko_init_xml_cdata(void);
+void noko_init_xml_comment(void);
+void noko_init_xml_document(void);
+void noko_init_xml_document_fragment(void);
+void noko_init_xml_dtd(void);
+void noko_init_xml_element_content(void);
+void noko_init_xml_element_decl(void);
+void noko_init_xml_encoding_handler(void);
+void noko_init_xml_entity_decl(void);
+void noko_init_xml_entity_reference(void);
+void noko_init_xml_namespace(void);
+void noko_init_xml_node(void);
+void noko_init_xml_node_set(void);
+void noko_init_xml_processing_instruction(void);
+void noko_init_xml_reader(void);
+void noko_init_xml_relax_ng(void);
+void noko_init_xml_sax_parser(void);
+void noko_init_xml_sax_parser_context(void);
+void noko_init_xml_sax_push_parser(void);
+void noko_init_xml_schema(void);
+void noko_init_xml_syntax_error(void);
+void noko_init_xml_text(void);
+void noko_init_xml_xpath_context(void);
+void noko_init_xslt_stylesheet(void);
+void noko_init_html_document(void);
+void noko_init_html_element_description(void);
+void noko_init_html_entity_lookup(void);
+void noko_init_html_sax_parser_context(void);
+void noko_init_html_sax_push_parser(void);
+void noko_init_gumbo(void);
+void noko_init_test_global_handlers(void);
+
+static ID id_read, id_write, id_external_encoding;
+
+
+static VALUE
+noko_io_read_check(VALUE val)
+{
+  VALUE *args = (VALUE *)val;
+  return rb_funcall(args[0], id_read, 1, args[1]);
+}
+
+
+static VALUE
+noko_io_read_failed(VALUE arg, VALUE exc)
+{
+  return Qundef;
+}
+
+
+int
+noko_io_read(void *io, char *c_buffer, int c_buffer_len)
+{
+  VALUE rb_io = (VALUE)io;
+  VALUE rb_read_string, rb_args[2];
+  size_t n_bytes_read, safe_len;
+
+  rb_args[0] = rb_io;
+  rb_args[1] = INT2NUM(c_buffer_len);
+
+  rb_read_string = rb_rescue(noko_io_read_check, (VALUE)rb_args, noko_io_read_failed, 0);
+
+  if (NIL_P(rb_read_string)) { return 0; }
+  if (rb_read_string == Qundef) { return -1; }
+  if (TYPE(rb_read_string) != T_STRING) { return -1; }
+
+  n_bytes_read = (size_t)RSTRING_LEN(rb_read_string);
+  safe_len = (n_bytes_read > (size_t)c_buffer_len) ? (size_t)c_buffer_len : n_bytes_read;
+  memcpy(c_buffer, StringValuePtr(rb_read_string), safe_len);
+
+  return (int)safe_len;
+}
+
+
+static VALUE
+noko_io_write_check(VALUE rb_args)
+{
+  VALUE rb_io = ((VALUE *)rb_args)[0];
+  VALUE rb_output = ((VALUE *)rb_args)[1];
+  return rb_funcall(rb_io, id_write, 1, rb_output);
+}
+
+
+static VALUE
+noko_io_write_failed(VALUE arg, VALUE exc)
+{
+  return Qundef;
+}
+
+
+int
+noko_io_write(void *io, char *c_buffer, int c_buffer_len)
+{
+  VALUE rb_args[2], rb_n_bytes_written;
+  VALUE rb_io = (VALUE)io;
+  VALUE rb_enc = Qnil;
+  rb_encoding *io_encoding;
+
+  if (rb_respond_to(rb_io, id_external_encoding)) {
+    rb_enc = rb_funcall(rb_io, id_external_encoding, 0);
+  }
+  io_encoding = RB_NIL_P(rb_enc) ? rb_ascii8bit_encoding() : rb_to_encoding(rb_enc);
+
+  rb_args[0] = rb_io;
+  rb_args[1] = rb_enc_str_new(c_buffer, (long)c_buffer_len, io_encoding);
+
+  rb_n_bytes_written = rb_rescue(noko_io_write_check, (VALUE)rb_args, noko_io_write_failed, 0);
+  if (rb_n_bytes_written == Qundef) { return -1; }
+
+  return NUM2INT(rb_n_bytes_written);
+}
+
+
+int
+noko_io_close(void *io)
+{
+  return 0;
+}
+
+
+void
+Init_nokogiri(void)
+{
+  mNokogiri         = rb_define_module("Nokogiri");
+  mNokogiriGumbo    = rb_define_module_under(mNokogiri, "Gumbo");
+  mNokogiriHtml4     = rb_define_module_under(mNokogiri, "HTML4");
+  mNokogiriHtml4Sax  = rb_define_module_under(mNokogiriHtml4, "SAX");
+  mNokogiriHtml5    = rb_define_module_under(mNokogiri, "HTML5");
+  mNokogiriXml      = rb_define_module_under(mNokogiri, "XML");
+  mNokogiriXmlSax   = rb_define_module_under(mNokogiriXml, "SAX");
+  mNokogiriXmlXpath = rb_define_module_under(mNokogiriXml, "XPath");
+  mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
+
+  rb_const_set(mNokogiri, rb_intern("LIBXML_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXML_DOTTED_VERSION));
+  rb_const_set(mNokogiri, rb_intern("LIBXML_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xmlParserVersion));
+
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXSLT_DOTTED_VERSION));
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xsltEngineVersion));
+
+#ifdef NOKOGIRI_PACKAGED_LIBRARIES
+  rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qtrue);
+#  ifdef NOKOGIRI_PRECOMPILED_LIBRARIES
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qtrue);
+#  else
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qfalse);
+#  endif
+  rb_const_set(mNokogiri, rb_intern("LIBXML2_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXML2_PATCHES), " "));
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXSLT_PATCHES), " "));
+#else
+  rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qfalse);
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qfalse);
+  rb_const_set(mNokogiri, rb_intern("LIBXML2_PATCHES"), Qnil);
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_PATCHES"), Qnil);
+#endif
+
+#ifdef LIBXML_ICONV_ENABLED
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qtrue);
+#else
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qfalse);
+#endif
+
+#ifdef NOKOGIRI_OTHER_LIBRARY_VERSIONS
+  rb_const_set(mNokogiri, rb_intern("OTHER_LIBRARY_VERSIONS"), NOKOGIRI_STR_NEW2(NOKOGIRI_OTHER_LIBRARY_VERSIONS));
+#endif
+
+#if defined(_WIN32) && !defined(NOKOGIRI_PACKAGED_LIBRARIES)
+  /*
+   *  We choose *not* to do use Ruby's memory management functions with windows DLLs because of this
+   *  issue in libxml 2.9.12:
+   *
+   *    https://github.com/sparklemotion/nokogiri/issues/2241
+   *
+   *  If the atexit() issue gets fixed in a future version of libxml2, then we may be able to skip
+   *  this config only for the specific libxml2 versions 2.9.12.
+   *
+   *  Alternatively, now that Ruby has a generational GC, it might be OK to let libxml2 use its
+   *  default memory management functions (recall that this config was introduced to reduce memory
+   *  bloat and allow Ruby to GC more often); but we should *really* test with production workloads
+   *  before making that kind of a potentially-invasive change.
+   */
+  rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("default"));
+#else
+  rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("ruby"));
+  xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
+#endif
+
+  xmlInitParser();
+  exsltRegisterAll();
+
+  if (xsltExtModuleFunctionLookup((const xmlChar *)"date-time", EXSLT_DATE_NAMESPACE)) {
+    rb_const_set(mNokogiri, rb_intern("LIBXSLT_DATETIME_ENABLED"), Qtrue);
+  } else {
+    rb_const_set(mNokogiri, rb_intern("LIBXSLT_DATETIME_ENABLED"), Qfalse);
+  }
+
+  cNokogiriSyntaxError = rb_define_class_under(mNokogiri, "SyntaxError", rb_eStandardError);
+  noko_init_xml_syntax_error();
+  assert(cNokogiriXmlSyntaxError);
+  cNokogiriXmlXpathSyntaxError = rb_define_class_under(mNokogiriXmlXpath, "SyntaxError", cNokogiriXmlSyntaxError);
+
+  noko_init_xml_element_content();
+  noko_init_xml_encoding_handler();
+  noko_init_xml_namespace();
+  noko_init_xml_node_set();
+  noko_init_xml_reader();
+  noko_init_xml_sax_parser();
+  noko_init_xml_xpath_context();
+  noko_init_xslt_stylesheet();
+  noko_init_html_element_description();
+  noko_init_html_entity_lookup();
+
+  noko_init_xml_schema();
+  noko_init_xml_relax_ng();
+
+  noko_init_xml_sax_parser_context();
+  noko_init_html_sax_parser_context();
+
+  noko_init_xml_sax_push_parser();
+  noko_init_html_sax_push_parser();
+
+  noko_init_xml_node();
+  noko_init_xml_attr();
+  noko_init_xml_attribute_decl();
+  noko_init_xml_dtd();
+  noko_init_xml_element_decl();
+  noko_init_xml_entity_decl();
+  noko_init_xml_entity_reference();
+  noko_init_xml_processing_instruction();
+  assert(cNokogiriXmlNode);
+  cNokogiriXmlElement = rb_define_class_under(mNokogiriXml, "Element", cNokogiriXmlNode);
+  cNokogiriXmlCharacterData = rb_define_class_under(mNokogiriXml, "CharacterData", cNokogiriXmlNode);
+  noko_init_xml_comment();
+  noko_init_xml_text();
+  noko_init_xml_cdata();
+
+  noko_init_xml_document_fragment();
+  noko_init_xml_document();
+  noko_init_html_document();
+  noko_init_gumbo();
+
+  noko_init_test_global_handlers();
+
+  id_read = rb_intern("read");
+  id_write = rb_intern("write");
+  id_external_encoding = rb_intern("external_encoding");
+}

data/ext/nokogiri/nokogiri.h

@@ -0,0 +1,235 @@
+#ifndef NOKOGIRI_NATIVE
+#define NOKOGIRI_NATIVE
+
+#include <ruby/defines.h> // https://github.com/sparklemotion/nokogiri/issues/2696
+
+#ifdef _MSC_VER
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif /* WIN32_LEAN_AND_MEAN */
+
+#  ifndef WIN32
+#    define WIN32
+#  endif /* WIN32 */
+
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#  include <windows.h>
+#endif
+
+#ifdef _WIN32
+#  define NOKOPUBFUN __declspec(dllexport)
+#  define NOKOPUBVAR __declspec(dllexport) extern
+#else
+#  define NOKOPUBFUN
+#  define NOKOPUBVAR extern
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/entities.h>
+#include <libxml/xpath.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/relaxng.h>
+#include <libxml/xinclude.h>
+#include <libxml/c14n.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xpathInternals.h>
+
+#include <libxslt/extensions.h>
+#include <libxslt/xsltconfig.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
+#include <libxslt/xsltInternals.h>
+
+#include <libexslt/exslt.h>
+
+/* libxml2_backwards_compat.c */
+#ifndef HAVE_XMLFIRSTELEMENTCHILD
+xmlNodePtr xmlFirstElementChild(xmlNodePtr parent);
+xmlNodePtr xmlNextElementSibling(xmlNodePtr node);
+xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
+#endif
+
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
+
+
+#include <ruby.h>
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+#include <ruby/util.h>
+#include <ruby/version.h>
+
+#define NOKOGIRI_STR_NEW2(str) NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
+#define NOKOGIRI_STR_NEW(str, len) rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
+#define RBSTR_OR_QNIL(_str) (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
+
+#ifndef NORETURN_DECL
+#  if defined(__GNUC__)
+#    define NORETURN_DECL __attribute__ ((noreturn))
+#  else
+#    define NORETURN_DECL
+#  endif
+#endif
+
+#ifndef PRINTFLIKE_DECL
+#  if defined(__GNUC__)
+#    define PRINTFLIKE_DECL(stringidx, argidx) __attribute__ ((format(printf,stringidx,argidx)))
+#  else
+#    define PRINTFLIKE_DECL(stringidx, argidx)
+#  endif
+#endif
+
+#if defined(TRUFFLERUBY) && !defined(NOKOGIRI_PACKAGED_LIBRARIES)
+#  define TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
+#endif
+
+NOKOPUBVAR VALUE mNokogiri ;
+NOKOPUBVAR VALUE mNokogiriGumbo ;
+NOKOPUBVAR VALUE mNokogiriHtml4 ;
+NOKOPUBVAR VALUE mNokogiriHtml4Sax ;
+NOKOPUBVAR VALUE mNokogiriHtml5 ;
+NOKOPUBVAR VALUE mNokogiriXml ;
+NOKOPUBVAR VALUE mNokogiriXmlSax ;
+NOKOPUBVAR VALUE mNokogiriXmlXpath ;
+NOKOPUBVAR VALUE mNokogiriXslt ;
+
+NOKOPUBVAR VALUE cNokogiriEncodingHandler;
+NOKOPUBVAR VALUE cNokogiriSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXmlAttr;
+NOKOPUBVAR VALUE cNokogiriXmlAttributeDecl;
+NOKOPUBVAR VALUE cNokogiriXmlCData;
+NOKOPUBVAR VALUE cNokogiriXmlCharacterData;
+NOKOPUBVAR VALUE cNokogiriXmlComment;
+NOKOPUBVAR VALUE cNokogiriXmlDocument ;
+NOKOPUBVAR VALUE cNokogiriXmlDocumentFragment;
+NOKOPUBVAR VALUE cNokogiriXmlDtd;
+NOKOPUBVAR VALUE cNokogiriXmlElement ;
+NOKOPUBVAR VALUE cNokogiriXmlElementContent;
+NOKOPUBVAR VALUE cNokogiriXmlElementDecl;
+NOKOPUBVAR VALUE cNokogiriXmlEntityDecl;
+NOKOPUBVAR VALUE cNokogiriXmlEntityReference;
+NOKOPUBVAR VALUE cNokogiriXmlNamespace ;
+NOKOPUBVAR VALUE cNokogiriXmlNode ;
+NOKOPUBVAR VALUE cNokogiriXmlNodeSet ;
+NOKOPUBVAR VALUE cNokogiriXmlProcessingInstruction;
+NOKOPUBVAR VALUE cNokogiriXmlReader;
+NOKOPUBVAR VALUE cNokogiriXmlRelaxNG;
+NOKOPUBVAR VALUE cNokogiriXmlSaxParser ;
+NOKOPUBVAR VALUE cNokogiriXmlSaxParserContext;
+NOKOPUBVAR VALUE cNokogiriXmlSaxPushParser ;
+NOKOPUBVAR VALUE cNokogiriXmlSchema;
+NOKOPUBVAR VALUE cNokogiriXmlSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXmlText ;
+NOKOPUBVAR VALUE cNokogiriXmlXpathContext;
+NOKOPUBVAR VALUE cNokogiriXmlXpathSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXsltStylesheet ;
+
+NOKOPUBVAR VALUE cNokogiriHtml4Document ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxPushParser ;
+NOKOPUBVAR VALUE cNokogiriHtml4ElementDescription ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxParserContext;
+NOKOPUBVAR VALUE cNokogiriHtml5Document ;
+
+typedef struct _nokogiriTuple {
+  VALUE         doc;
+  st_table     *unlinkedNodes;
+  VALUE         node_cache;
+} nokogiriTuple;
+typedef nokogiriTuple *nokogiriTuplePtr;
+
+typedef struct _nokogiriSAXTuple {
+  xmlParserCtxtPtr  ctxt;
+  VALUE             self;
+} nokogiriSAXTuple;
+typedef nokogiriSAXTuple *nokogiriSAXTuplePtr;
+
+typedef struct _libxmlStructuredErrorHandlerState {
+  void *user_data;
+  xmlStructuredErrorFunc handler;
+} libxmlStructuredErrorHandlerState ;
+
+typedef struct _nokogiriXsltStylesheetTuple {
+  xsltStylesheetPtr ss;
+  VALUE func_instances;
+} nokogiriXsltStylesheetTuple;
+
+void noko_xml_document_pin_node(xmlNodePtr);
+void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
+
+int noko_io_read(void *ctx, char *buffer, int len);
+int noko_io_write(void *ctx, char *buffer, int len);
+int noko_io_close(void *ctx);
+
+#define Noko_Node_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
+#define Noko_Namespace_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
+
+VALUE noko_xml_node_wrap(VALUE klass, xmlNodePtr node) ;
+VALUE noko_xml_node_wrap_node_set_result(xmlNodePtr node, VALUE node_set) ;
+VALUE noko_xml_node_attrs(xmlNodePtr node) ;
+
+VALUE noko_xml_namespace_wrap(xmlNsPtr node, xmlDocPtr doc);
+VALUE noko_xml_namespace_wrap_xpath_copy(xmlNsPtr node);
+
+VALUE noko_xml_element_content_wrap(VALUE doc, xmlElementContentPtr element);
+
+VALUE noko_xml_node_set_wrap(xmlNodeSetPtr node_set, VALUE document) ;
+
+VALUE noko_xml_document_wrap_with_init_args(VALUE klass, xmlDocPtr doc, int argc, VALUE *argv);
+VALUE noko_xml_document_wrap(VALUE klass, xmlDocPtr doc);
+NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
+    xmlDocPtr doc); /* deprecated. use noko_xml_document_wrap() instead. */
+
+#define DOC_RUBY_OBJECT_TEST(x) ((nokogiriTuplePtr)(x->_private))
+#define DOC_RUBY_OBJECT(x) (((nokogiriTuplePtr)(x->_private))->doc)
+#define DOC_UNLINKED_NODE_HASH(x) (((nokogiriTuplePtr)(x->_private))->unlinkedNodes)
+#define DOC_NODE_CACHE(x) (((nokogiriTuplePtr)(x->_private))->node_cache)
+#define NOKOGIRI_NAMESPACE_EH(node) ((node)->type == XML_NAMESPACE_DECL)
+
+#define NOKOGIRI_SAX_SELF(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->self
+#define NOKOGIRI_SAX_CTXT(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->ctxt
+#define NOKOGIRI_SAX_TUPLE_NEW(_ctxt, _self) nokogiri_sax_tuple_new(_ctxt, _self)
+#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) ruby_xfree(_tuple)
+
+#define DISCARD_CONST_QUAL(t, v) ((t)(uintptr_t)(v))
+#define DISCARD_CONST_QUAL_XMLCHAR(v) DISCARD_CONST_QUAL(xmlChar *, v)
+
+#if HAVE_RB_CATEGORY_WARNING
+#  define NOKO_WARN_DEPRECATION(message) rb_category_warning(RB_WARN_CATEGORY_DEPRECATED, message)
+#else
+#  define NOKO_WARN_DEPRECATION(message) rb_warning(message)
+#endif
+
+void Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);
+void Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state, void *user_data,
+    xmlStructuredErrorFunc handler);
+void Nokogiri_structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state);
+VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error);
+void Nokogiri_error_array_pusher(void *ctx, xmlErrorPtr error);
+NORETURN_DECL void Nokogiri_error_raise(void *ctx, xmlErrorPtr error);
+void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
+    const char *function_name) ;
+
+static inline
+nokogiriSAXTuplePtr
+nokogiri_sax_tuple_new(xmlParserCtxtPtr ctxt, VALUE self)
+{
+  nokogiriSAXTuplePtr tuple = ruby_xmalloc(sizeof(nokogiriSAXTuple));
+  tuple->self = self;
+  tuple->ctxt = ctxt;
+  return tuple;
+}
+
+#endif /* NOKOGIRI_NATIVE */

data/ext/nokogiri/test_global_handlers.c

@@ -0,0 +1,42 @@
+#include <nokogiri.h>
+
+static VALUE foreign_error_handler_block = Qnil;
+void xmlSetStructuredErrorFunc(void *aaa, void*bbb);
+
+
+static void
+foreign_error_handler(void *user_data, xmlErrorPtr c_error)
+{
+  rb_funcall(foreign_error_handler_block, rb_intern("call"), 0);
+}
+
+/*
+ * call-seq:
+ *   __foreign_error_handler { ... } -> nil
+ *
+ * Override libxml2's global error handlers to call the block. This method thus has very little
+ * value except to test that Nokogiri is properly setting error handlers elsewhere in the code. See
+ * test/helper.rb for how this is being used.
+ */
+static VALUE
+rb_foreign_error_handler(VALUE klass)
+{
+  rb_need_block();
+  foreign_error_handler_block = rb_block_proc();
+  xmlSetStructuredErrorFunc(NULL, foreign_error_handler);
+  return Qnil;
+}
+
+/*
+ *  Document-module: Nokogiri::Test
+ *
+ *  The Nokogiri::Test module should only be used for testing Nokogiri.
+ *  Do NOT use this outside of the Nokogiri test suite.
+ */
+void
+noko_init_test_global_handlers(void)
+{
+  VALUE mNokogiriTest = rb_define_module_under(mNokogiri, "Test");
+
+  rb_define_singleton_method(mNokogiriTest, "__foreign_error_handler", rb_foreign_error_handler, 0);
+}