nokogiri 1.13.6 → 1.14.2

data/ext/nokogiri/nokogiri.c

@@ -49,34 +49,11 @@ 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;
-
-
-#ifndef HAVE_VASPRINTF
-/*
- * Thank you Geoffroy Couprie for this implementation of vasprintf!
- */
-int
-vasprintf(char **strp, const char *fmt, va_list ap)
-{
-  /* Mingw32/64 have a broken vsnprintf implementation that fails when
-   * using a zero-byte limit in order to retrieve the required size for malloc.
-   * So we use a one byte buffer instead.
-   */
-  char tmp[1];
-  int len = vsnprintf(tmp, 1, fmt, ap) + 1;
-  char *res = (char *)malloc((unsigned int)len);
-  if (res == NULL) {
-    return -1;
-  }
-  *strp = res;
-  return vsnprintf(res, (unsigned int)len, fmt, ap);
-}
-#endif
+static ID id_read, id_write, id_external_encoding;
 
 
 static VALUE
-read_check(VALUE val)
+noko_io_read_check(VALUE val)
 {
   VALUE *args = (VALUE *)val;
   return rb_funcall(args[0], id_read, 1, args[1]);
@@ -84,75 +61,84 @@ read_check(VALUE val)
 
 
 static VALUE
-read_failed(VALUE arg, VALUE exc)
+noko_io_read_failed(VALUE arg, VALUE exc)
 {
   return Qundef;
 }
 
 
 int
-noko_io_read(void *ctx, char *buffer, int len)
+noko_io_read(void *io, char *c_buffer, int c_buffer_len)
 {
-  VALUE string, args[2];
-  size_t str_len, safe_len;
+  VALUE rb_io = (VALUE)io;
+  VALUE rb_read_string, rb_args[2];
+  size_t n_bytes_read, safe_len;
 
-  args[0] = (VALUE)ctx;
-  args[1] = INT2NUM(len);
+  rb_args[0] = rb_io;
+  rb_args[1] = INT2NUM(c_buffer_len);
 
-  string = rb_rescue(read_check, (VALUE)args, read_failed, 0);
+  rb_read_string = rb_rescue(noko_io_read_check, (VALUE)rb_args, noko_io_read_failed, 0);
 
-  if (NIL_P(string)) { return 0; }
-  if (string == Qundef) { return -1; }
-  if (TYPE(string) != T_STRING) { return -1; }
+  if (NIL_P(rb_read_string)) { return 0; }
+  if (rb_read_string == Qundef) { return -1; }
+  if (TYPE(rb_read_string) != T_STRING) { return -1; }
 
-  str_len = (size_t)RSTRING_LEN(string);
-  safe_len = str_len > (size_t)len ? (size_t)len : str_len;
-  memcpy(buffer, StringValuePtr(string), safe_len);
+  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
-write_check(VALUE val)
+noko_io_write_check(VALUE rb_args)
 {
-  VALUE *args = (VALUE *)val;
-  return rb_funcall(args[0], id_write, 1, args[1]);
+  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
-write_failed(VALUE arg, VALUE exc)
+noko_io_write_failed(VALUE arg, VALUE exc)
 {
   return Qundef;
 }
 
 
 int
-noko_io_write(void *ctx, char *buffer, int len)
+noko_io_write(void *io, char *c_buffer, int c_buffer_len)
 {
-  VALUE args[2], size;
+  VALUE rb_args[2], rb_n_bytes_written;
+  VALUE rb_io = (VALUE)io;
+  VALUE rb_enc = Qnil;
+  rb_encoding *io_encoding;
 
-  args[0] = (VALUE)ctx;
-  args[1] = rb_str_new(buffer, (long)len);
+  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);
 
-  size = rb_rescue(write_check, (VALUE)args, write_failed, 0);
+  rb_args[0] = rb_io;
+  rb_args[1] = rb_enc_str_new(c_buffer, (long)c_buffer_len, io_encoding);
 
-  if (size == Qundef) { return -1; }
+  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(size);
+  return NUM2INT(rb_n_bytes_written);
 }
 
 
 int
-noko_io_close(void *ctx)
+noko_io_close(void *io)
 {
   return 0;
 }
 
 
 void
-Init_nokogiri()
+Init_nokogiri(void)
 {
   mNokogiri         = rb_define_module("Nokogiri");
   mNokogiriGumbo    = rb_define_module_under(mNokogiri, "Gumbo");
@@ -275,4 +261,5 @@ Init_nokogiri()
 
   id_read = rb_intern("read");
   id_write = rb_intern("write");
+  id_external_encoding = rb_intern("external_encoding");
 }

data/ext/nokogiri/nokogiri.h

@@ -1,6 +1,8 @@
 #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
@@ -23,7 +25,6 @@
 #  define NOKOPUBVAR extern
 #endif
 
-
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
@@ -75,22 +76,25 @@ xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
 #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)
 
-#ifdef DEBUG
-#  define NOKOGIRI_DEBUG_START(p) if (getenv("NOKOGIRI_NO_FREE")) return ; if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p start\n", __FILE__, __LINE__, p);
-#  define NOKOGIRI_DEBUG_END(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p end\n", __FILE__, __LINE__, p);
-#else
-#  define NOKOGIRI_DEBUG_START(p)
-#  define NOKOGIRI_DEBUG_END(p)
+#ifndef NORETURN_DECL
+#  if defined(__GNUC__)
+#    define NORETURN_DECL __attribute__ ((noreturn))
+#  else
+#    define NORETURN_DECL
+#  endif
 #endif
 
-#ifndef NORETURN
+#ifndef PRINTFLIKE_DECL
 #  if defined(__GNUC__)
-#    define NORETURN(name) __attribute__((noreturn)) name
+#    define PRINTFLIKE_DECL(stringidx, argidx) __attribute__ ((format(printf,stringidx,argidx)))
 #  else
-#    define NORETURN(name) name
+#    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 ;
@@ -162,7 +166,6 @@ typedef struct _nokogiriXsltStylesheetTuple {
   VALUE func_instances;
 } nokogiriXsltStylesheetTuple;
 
-int vasprintf(char **strp, const char *fmt, va_list ap);
 void noko_xml_document_pin_node(xmlNodePtr);
 void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
 
@@ -170,6 +173,9 @@ 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) ;
@@ -195,18 +201,24 @@ NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
 #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) free(_tuple)
+#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(void Nokogiri_error_raise(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) ;
 
@@ -214,7 +226,7 @@ static inline
 nokogiriSAXTuplePtr
 nokogiri_sax_tuple_new(xmlParserCtxtPtr ctxt, VALUE self)
 {
-  nokogiriSAXTuplePtr tuple = malloc(sizeof(nokogiriSAXTuple));
+  nokogiriSAXTuplePtr tuple = ruby_xmalloc(sizeof(nokogiriSAXTuple));
   tuple->self = self;
   tuple->ctxt = ctxt;
   return tuple;

data/ext/nokogiri/test_global_handlers.c

@@ -32,7 +32,7 @@ rb_foreign_error_handler(VALUE klass)
  *  Do NOT use this outside of the Nokogiri test suite.
  */
 void
-noko_init_test_global_handlers()
+noko_init_test_global_handlers(void)
 {
   VALUE mNokogiriTest = rb_define_module_under(mNokogiri, "Test");
 

data/ext/nokogiri/xml_attr.c

@@ -16,7 +16,7 @@ set_value(VALUE self, VALUE content)
   xmlChar *value;
   xmlNode *cur;
 
-  Data_Get_Struct(self, xmlAttr, attr);
+  Noko_Node_Get_Struct(self, xmlAttr, attr);
 
   if (attr->children) {
     xmlFreeNodeList(attr->children);
@@ -68,7 +68,7 @@ new (int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eArgError, "parameter must be a Nokogiri::XML::Document");
   }
 
-  Data_Get_Struct(document, xmlDoc, xml_doc);
+  Noko_Node_Get_Struct(document, xmlDoc, xml_doc);
 
   node = xmlNewDocProp(
            xml_doc,
@@ -89,7 +89,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_attr()
+noko_init_xml_attr(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_attribute_decl.c

@@ -12,8 +12,8 @@ static VALUE
 attribute_type(VALUE self)
 {
   xmlAttributePtr node;
-  Data_Get_Struct(self, xmlAttribute, node);
-  return INT2NUM((long)node->atype);
+  Noko_Node_Get_Struct(self, xmlAttribute, node);
+  return INT2NUM(node->atype);
 }
 
 /*
@@ -26,7 +26,7 @@ static VALUE
 default_value(VALUE self)
 {
   xmlAttributePtr node;
-  Data_Get_Struct(self, xmlAttribute, node);
+  Noko_Node_Get_Struct(self, xmlAttribute, node);
 
   if (node->defaultValue) { return NOKOGIRI_STR_NEW2(node->defaultValue); }
   return Qnil;
@@ -45,7 +45,7 @@ enumeration(VALUE self)
   xmlEnumerationPtr enm;
   VALUE list;
 
-  Data_Get_Struct(self, xmlAttribute, node);
+  Noko_Node_Get_Struct(self, xmlAttribute, node);
 
   list = rb_ary_new();
   enm = node->tree;
@@ -59,7 +59,7 @@ enumeration(VALUE self)
 }
 
 void
-noko_init_xml_attribute_decl()
+noko_init_xml_attribute_decl(void)
 {
   assert(cNokogiriXmlNode);
   cNokogiriXmlAttributeDecl = rb_define_class_under(mNokogiriXml, "AttributeDecl", cNokogiriXmlNode);

data/ext/nokogiri/xml_cdata.c

@@ -25,11 +25,11 @@ new (int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &doc, &content, &rest);
 
-  Data_Get_Struct(doc, xmlDoc, xml_doc);
+  Noko_Node_Get_Struct(doc, xmlDoc, xml_doc);
 
   if (!NIL_P(content)) {
     content_str = (xmlChar *)StringValuePtr(content);
-    content_str_len = RSTRING_LEN(content);
+    content_str_len = RSTRING_LENINT(content);
   }
 
   node = xmlNewCDataBlock(xml_doc->doc, content_str, content_str_len);
@@ -45,7 +45,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_cdata()
+noko_init_xml_cdata(void)
 {
   assert(cNokogiriXmlText);
   /*

data/ext/nokogiri/xml_comment.c

@@ -48,7 +48,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_comment()
+noko_init_xml_comment(void)
 {
   assert(cNokogiriXmlCharacterData);
   /*

data/ext/nokogiri/xml_document.c

@@ -65,14 +65,12 @@ dealloc(xmlDocPtr doc)
 {
   st_table *node_hash;
 
-  NOKOGIRI_DEBUG_START(doc);
-
   node_hash  = DOC_UNLINKED_NODE_HASH(doc);
 
   st_foreach(node_hash, dealloc_node_i, (st_data_t)doc);
   st_free_table(node_hash);
 
-  free(doc->_private);
+  ruby_xfree(doc->_private);
 
   /* When both Nokogiri and libxml-ruby are loaded, make sure that all nodes
    * have their _private pointers cleared. This is to avoid libxml-ruby's
@@ -84,8 +82,6 @@ dealloc(xmlDocPtr doc)
   }
 
   xmlFreeDoc(doc);
-
-  NOKOGIRI_DEBUG_END(doc);
 }
 
 static void
@@ -104,7 +100,11 @@ recursively_remove_namespaces_from_node(xmlNodePtr node)
        (node->type == XML_XINCLUDE_START) ||
        (node->type == XML_XINCLUDE_END)) &&
       node->nsDef) {
-    xmlFreeNsList(node->nsDef);
+    xmlNsPtr curr = node->nsDef;
+    while (curr) {
+      noko_xml_document_pin_namespace(curr, node->doc);
+      curr = curr->next;
+    }
     node->nsDef = NULL;
   }
 
@@ -161,7 +161,7 @@ rb_xml_document_root_set(VALUE self, VALUE rb_new_root)
                rb_obj_class(rb_new_root));
     }
 
-    Data_Get_Struct(rb_new_root, xmlNode, c_new_root);
+    Noko_Node_Get_Struct(rb_new_root, xmlNode, c_new_root);
 
     /* If the new root's document is not the same as the current document,
      * then we need to dup the node in to this document. */
@@ -536,6 +536,7 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   VALUE rb_mode;
   VALUE rb_namespaces;
   VALUE rb_comments_p;
+  int c_mode = 0;
   xmlChar **c_namespaces;
 
   xmlDocPtr c_doc;
@@ -547,8 +548,16 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   VALUE rb_io;
 
   rb_scan_args(argc, argv, "03", &rb_mode, &rb_namespaces, &rb_comments_p);
-  if (!NIL_P(rb_mode)) { Check_Type(rb_mode, T_FIXNUM); }
-  if (!NIL_P(rb_namespaces)) { Check_Type(rb_namespaces, T_ARRAY); }
+  if (!NIL_P(rb_mode)) {
+    Check_Type(rb_mode, T_FIXNUM);
+    c_mode = NUM2INT(rb_mode);
+  }
+  if (!NIL_P(rb_namespaces)) {
+    Check_Type(rb_namespaces, T_ARRAY);
+    if (c_mode == XML_C14N_1_0 || c_mode == XML_C14N_1_1) {
+      rb_raise(rb_eRuntimeError, "This canonicalizer does not support this operation");
+    }
+  }
 
   Data_Get_Struct(self, xmlDoc, c_doc);
 
@@ -569,7 +578,7 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
     c_namespaces = NULL;
   } else {
     long ns_len = RARRAY_LEN(rb_namespaces);
-    c_namespaces = calloc((size_t)ns_len + 1, sizeof(xmlChar *));
+    c_namespaces = ruby_xcalloc((size_t)ns_len + 1, sizeof(xmlChar *));
     for (int j = 0 ; j < ns_len ; j++) {
       VALUE entry = rb_ary_entry(rb_namespaces, j);
       c_namespaces[j] = (xmlChar *)StringValueCStr(entry);
@@ -577,12 +586,12 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   }
 
   xmlC14NExecute(c_doc, c_callback_wrapper, rb_callback,
-                 (int)(NIL_P(rb_mode) ? 0 : NUM2INT(rb_mode)),
+                 c_mode,
                  c_namespaces,
                  (int)RTEST(rb_comments_p),
                  c_obuf);
 
-  free(c_namespaces);
+  ruby_xfree(c_namespaces);
   xmlOutputBufferClose(c_obuf);
 
   return rb_funcall(rb_io, rb_intern("string"), 0);
@@ -600,7 +609,7 @@ noko_xml_document_wrap_with_init_args(VALUE klass, xmlDocPtr c_document, int arg
 
   rb_document = Data_Wrap_Struct(klass, mark, dealloc, c_document);
 
-  tuple = (nokogiriTuplePtr)malloc(sizeof(nokogiriTuple));
+  tuple = (nokogiriTuplePtr)ruby_xmalloc(sizeof(nokogiriTuple));
   tuple->doc = rb_document;
   tuple->unlinkedNodes = st_init_numtable_with_size(128);
   tuple->node_cache = rb_ary_new();
@@ -655,7 +664,7 @@ noko_xml_document_pin_namespace(xmlNsPtr ns, xmlDocPtr doc)
 
 
 void
-noko_init_xml_document()
+noko_init_xml_document(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_document_fragment.c

@@ -32,7 +32,7 @@ new (int argc, VALUE *argv, VALUE klass)
 }
 
 void
-noko_init_xml_document_fragment()
+noko_init_xml_document_fragment(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_dtd.c

@@ -44,7 +44,7 @@ entities(VALUE self)
   xmlDtdPtr dtd;
   VALUE hash;
 
-  Data_Get_Struct(self, xmlDtd, dtd);
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
 
   if (!dtd->entities) { return Qnil; }
 
@@ -67,7 +67,7 @@ notations(VALUE self)
   xmlDtdPtr dtd;
   VALUE hash;
 
-  Data_Get_Struct(self, xmlDtd, dtd);
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
 
   if (!dtd->notations) { return Qnil; }
 
@@ -90,7 +90,7 @@ attributes(VALUE self)
   xmlDtdPtr dtd;
   VALUE hash;
 
-  Data_Get_Struct(self, xmlDtd, dtd);
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
 
   hash = rb_hash_new();
 
@@ -113,7 +113,7 @@ elements(VALUE self)
   xmlDtdPtr dtd;
   VALUE hash;
 
-  Data_Get_Struct(self, xmlDtd, dtd);
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
 
   if (!dtd->elements) { return Qnil; }
 
@@ -138,8 +138,8 @@ validate(VALUE self, VALUE document)
   xmlValidCtxtPtr ctxt;
   VALUE error_list;
 
-  Data_Get_Struct(self, xmlDtd, dtd);
-  Data_Get_Struct(document, xmlDoc, doc);
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+  Noko_Node_Get_Struct(document, xmlDoc, doc);
   error_list = rb_ary_new();
 
   ctxt = xmlNewValidCtxt();
@@ -165,7 +165,7 @@ static VALUE
 system_id(VALUE self)
 {
   xmlDtdPtr dtd;
-  Data_Get_Struct(self, xmlDtd, dtd);
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
 
   if (!dtd->SystemID) { return Qnil; }
 
@@ -182,7 +182,7 @@ static VALUE
 external_id(VALUE self)
 {
   xmlDtdPtr dtd;
-  Data_Get_Struct(self, xmlDtd, dtd);
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
 
   if (!dtd->ExternalID) { return Qnil; }
 
@@ -190,7 +190,7 @@ external_id(VALUE self)
 }
 
 void
-noko_init_xml_dtd()
+noko_init_xml_dtd(void)
 {
   assert(cNokogiriXmlNode);
   /*

data/ext/nokogiri/xml_element_content.c

@@ -31,7 +31,7 @@ get_type(VALUE self)
   xmlElementContentPtr elem;
   Data_Get_Struct(self, xmlElementContent, elem);
 
-  return INT2NUM((long)elem->type);
+  return INT2NUM(elem->type);
 }
 
 /*
@@ -79,7 +79,7 @@ get_occur(VALUE self)
   xmlElementContentPtr elem;
   Data_Get_Struct(self, xmlElementContent, elem);
 
-  return INT2NUM((long)elem->ocur);
+  return INT2NUM(elem->ocur);
 }
 
 /*
@@ -112,7 +112,7 @@ noko_xml_element_content_wrap(VALUE doc, xmlElementContentPtr element)
 }
 
 void
-noko_init_xml_element_content()
+noko_init_xml_element_content(void)
 {
   cNokogiriXmlElementContent = rb_define_class_under(mNokogiriXml, "ElementContent", rb_cObject);
 

data/ext/nokogiri/xml_element_decl.c

@@ -14,8 +14,8 @@ static VALUE
 element_type(VALUE self)
 {
   xmlElementPtr node;
-  Data_Get_Struct(self, xmlElement, node);
-  return INT2NUM((long)node->etype);
+  Noko_Node_Get_Struct(self, xmlElement, node);
+  return INT2NUM(node->etype);
 }
 
 /*
@@ -28,7 +28,7 @@ static VALUE
 content(VALUE self)
 {
   xmlElementPtr node;
-  Data_Get_Struct(self, xmlElement, node);
+  Noko_Node_Get_Struct(self, xmlElement, node);
 
   if (!node->content) { return Qnil; }
 
@@ -48,7 +48,7 @@ static VALUE
 prefix(VALUE self)
 {
   xmlElementPtr node;
-  Data_Get_Struct(self, xmlElement, node);
+  Noko_Node_Get_Struct(self, xmlElement, node);
 
   if (!node->prefix) { return Qnil; }
 
@@ -56,7 +56,7 @@ prefix(VALUE self)
 }
 
 void
-noko_init_xml_element_decl()
+noko_init_xml_element_decl(void)
 {
   assert(cNokogiriXmlNode);
   cNokogiriXmlElementDecl = rb_define_class_under(mNokogiriXml, "ElementDecl", cNokogiriXmlNode);

data/ext/nokogiri/xml_encoding_handler.c

@@ -45,9 +45,9 @@ rb_xml_encoding_handler_s_delete(VALUE klass, VALUE name)
 
 
 /*
- * call-seq: Nokogiri::EncodingHandler.alias(from, to)
+ * call-seq: Nokogiri::EncodingHandler.alias(real_name, alias_name)
  *
- * Alias encoding handler with name +from+ to name +to+
+ * Alias encoding handler with name +real_name+ to name +alias_name+
  */
 static VALUE
 rb_xml_encoding_handler_s_alias(VALUE klass, VALUE from, VALUE to)
@@ -89,7 +89,7 @@ rb_xml_encoding_handler_name(VALUE self)
 
 
 void
-noko_init_xml_encoding_handler()
+noko_init_xml_encoding_handler(void)
 {
   cNokogiriEncodingHandler = rb_define_class_under(mNokogiri, "EncodingHandler", rb_cObject);