libxml-ruby 0.9.2-x86-mswin32-60 → 0.9.3-x86-mswin32-60

data/ext/libxml/ruby_xml_xpath_context.h

@@ -1,15 +1,11 @@
-/* $Id: ruby_xml_xpath_context.h 412 2008-07-14 08:02:47Z cfis $ */
+/* $Id: ruby_xml_xpath_context.h 614 2008-11-22 08:04:39Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_XPATH_CONTEXT__
-#define __RUBY_XML_XPATH_CONTEXT__
+#ifndef __rxml_XPATH_CONTEXT__
+#define __rxml_XPATH_CONTEXT__
 
 extern VALUE cXMLXPathContext;
 void ruby_init_xml_xpath_context(void);
 
-VALUE ruby_xml_xpath_context_register_namespaces(VALUE self, VALUE nslist);
-VALUE ruby_xml_xpath_context_register_namespaces_from_node(VALUE self, VALUE node);
-VALUE ruby_xml_xpath_context_find(VALUE self, VALUE xpath_expr);
-
 #endif

data/ext/libxml/ruby_xml_xpath_expression.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpath.c 461 2008-07-15 21:35:56Z cfis $ */
+/* $Id: rxml_xpath.c 461 2008-07-15 21:35:56Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -23,16 +23,16 @@
 
 VALUE cXMLXPathExpression;
 
-void
-ruby_xml_xpath_expression_free(xmlXPathCompExprPtr expr) {
+static void
+rxml_xpath_expression_free(xmlXPathCompExprPtr expr) {
   xmlXPathFreeCompExpr(expr);
 }
 
-VALUE
-ruby_xml_xpath_expression_alloc(VALUE klass) {
+static VALUE
+rxml_xpath_expression_alloc(VALUE klass) {
   return Data_Wrap_Struct(cXMLXPathExpression,
 						  NULL,
-						  ruby_xml_xpath_expression_free,
+						  rxml_xpath_expression_free,
 						  NULL);
 }
 
@@ -46,13 +46,13 @@ ruby_xml_xpath_expression_alloc(VALUE klass) {
  *  expr = XPath::Expression.new('//first')
  *  nodes = doc.find(expr)
  */
-VALUE
-ruby_xml_xpath_expression_initialize(VALUE self, VALUE expression) {
+static VALUE
+rxml_xpath_expression_initialize(VALUE self, VALUE expression) {
   xmlXPathCompExprPtr compexpr = xmlXPathCompile(StringValueCStr(expression));  
 
   if (compexpr == NULL) {
 	  xmlErrorPtr xerror = xmlGetLastError();
-	  ruby_xml_raise(xerror);
+	  rxml_raise(xerror);
   }
 
   DATA_PTR(self) = compexpr;
@@ -62,8 +62,8 @@ ruby_xml_xpath_expression_initialize(VALUE self, VALUE expression) {
 void
 ruby_init_xml_xpath_expression(void) {
   cXMLXPathExpression = rb_define_class_under(mXPath, "Expression", rb_cObject);
-  rb_define_alloc_func(cXMLXPathExpression, ruby_xml_xpath_expression_alloc);
+  rb_define_alloc_func(cXMLXPathExpression, rxml_xpath_expression_alloc);
   rb_define_singleton_method(rb_cRegexp, "compile", rb_class_new_instance, 1);
 
-  rb_define_method(cXMLXPathExpression, "initialize", ruby_xml_xpath_expression_initialize, 1);
+  rb_define_method(cXMLXPathExpression, "initialize", rxml_xpath_expression_initialize, 1);
 }

data/ext/libxml/ruby_xml_xpath_expression.h

@@ -2,8 +2,8 @@
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_XPATH_EXPRESSION__
-#define __RUBY_XML_XPATH_EXPRESSION__
+#ifndef __rxml_XPATH_EXPRESSION__
+#define __rxml_XPATH_EXPRESSION__
 
 extern VALUE cXMLXPathExpression;
 

data/ext/libxml/ruby_xml_xpath_object.c

@@ -12,8 +12,8 @@
 VALUE cXMLXPathObject;
 
 
-xmlDocPtr
-ruby_xml_xpath_object_doc(xmlXPathObjectPtr xpop)
+static xmlDocPtr
+rxml_xpath_object_doc(xmlXPathObjectPtr xpop)
 {
   xmlDocPtr result = NULL;
   xmlNodePtr *nodes = NULL;
@@ -32,14 +32,14 @@ ruby_xml_xpath_object_doc(xmlXPathObjectPtr xpop)
   return (*nodes)->doc;
 }
 
-void
-ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop)
+static void
+rxml_xpath_object_mark(xmlXPathObjectPtr xpop)
 {
   int i;
 
   if ( xpop->type == XPATH_NODESET && xpop->nodesetval != NULL ) 
   {
-    xmlDocPtr xdoc = ruby_xml_xpath_object_doc(xpop);
+    xmlDocPtr xdoc = rxml_xpath_object_doc(xpop);
     if (xdoc && xdoc->_private)
       rb_gc_mark((VALUE)xdoc->_private);
 
@@ -51,27 +51,17 @@ ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop)
   }
 }
 
-void
-ruby_xml_xpath_object_free(xmlXPathObjectPtr xpop)
+static void
+rxml_xpath_object_free(xmlXPathObjectPtr xpop)
 {
-  /* Before freeing this xpath object, get the 
-     document it is dependent on if its a nodeset. */
-  xmlDocPtr xdoc = ruby_xml_xpath_object_doc(xpop);
-
-  /* Now free the xpath result */
-  xmlXPathFreeObject(xpop);
-
-  /* Now decrement the document object if this was a 
-     XPATH_NODESET.  Note this could free the document,
-     which is why we do it after freeing xpop.*/
-  if (xdoc)
-    ruby_xml_document_decr(xdoc);
+  /* Now free the xpath result but not underlying nodes
+     since those belong to the document. */
+  xmlXPathFreeNodeSetList(xpop);
 }
 
 VALUE
-ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop)
+rxml_xpath_object_wrap(xmlXPathObjectPtr xpop)
 {
-  xmlDocPtr xdoc;
   VALUE rval;
 
   if ( xpop==NULL )
@@ -79,13 +69,9 @@ ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop)
 
   switch(xpop->type) {
   case XPATH_NODESET:
-    xdoc = ruby_xml_xpath_object_doc(xpop);
-    if (xdoc)
-      ruby_xml_document_incr(xdoc);
-    
     rval = Data_Wrap_Struct(cXMLXPathObject,
-                            ruby_xml_xpath_object_mark,
-                            ruby_xml_xpath_object_free,
+                            rxml_xpath_object_mark,
+                            rxml_xpath_object_free,
                             xpop);
   
     break;
@@ -115,7 +101,7 @@ ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop)
 }
 
 static VALUE
-ruby_xml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
+rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
 
   if (apos < 0 )
     apos=xpop->nodesetval->nodeNr+apos;
@@ -125,10 +111,10 @@ ruby_xml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
 
   switch(xpop->nodesetval->nodeTab[apos]->type) {
   case XML_ATTRIBUTE_NODE:
-    return ruby_xml_attr_wrap((xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
+    return rxml_attr_wrap((xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
     break;
   default:
-    return ruby_xml_node2_wrap(cXMLNode,
+    return rxml_node2_wrap(cXMLNode,
 			       xpop->nodesetval->nodeTab[apos]);
   }
 }
@@ -139,8 +125,8 @@ ruby_xml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
  * 
  * Obtain an array of the nodes in this set.
  */
-VALUE
-ruby_xml_xpath_object_to_a(VALUE self)
+static VALUE
+rxml_xpath_object_to_a(VALUE self)
 {
   VALUE set_ary, nodeobj;
   xmlXPathObjectPtr xpop;
@@ -151,7 +137,7 @@ ruby_xml_xpath_object_to_a(VALUE self)
   set_ary = rb_ary_new();
   if (!((xpop->nodesetval == NULL) || (xpop->nodesetval->nodeNr == 0))) {
     for (i = 0; i < xpop->nodesetval->nodeNr; i++) {
-      nodeobj = ruby_xml_xpath_object_tabref(xpop, i);
+      nodeobj = rxml_xpath_object_tabref(xpop, i);
       rb_ary_push(set_ary, nodeobj);
     }
   }
@@ -165,8 +151,8 @@ ruby_xml_xpath_object_to_a(VALUE self)
  *
  * Determine whether this nodeset is empty (contains no nodes).
  */
-VALUE
-ruby_xml_xpath_object_empty_q(VALUE self) {
+static VALUE
+rxml_xpath_object_empty_q(VALUE self) {
   xmlXPathObjectPtr xpop;
 
   Data_Get_Struct(self,xmlXPathObject,xpop);
@@ -183,19 +169,19 @@ ruby_xml_xpath_object_empty_q(VALUE self) {
  * 
  * Call the supplied block for each node in this set.
  */
-VALUE
-ruby_xml_xpath_object_each(VALUE self)
+static VALUE
+rxml_xpath_object_each(VALUE self)
 {
   xmlXPathObjectPtr xpop;
   int i;
 
-  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+  if ( rxml_xpath_object_empty_q(self) == Qtrue )
     return Qnil;
 
   Data_Get_Struct(self,xmlXPathObject,xpop);
 
   for (i = 0; i < xpop->nodesetval->nodeNr; i++) {
-    rb_yield(ruby_xml_xpath_object_tabref(xpop,i));
+    rb_yield(rxml_xpath_object_tabref(xpop,i));
   }
   return(self);
 }
@@ -206,12 +192,12 @@ ruby_xml_xpath_object_each(VALUE self)
  *
  * Returns the first node in this node set, or nil if none exist.
  */
-VALUE
-ruby_xml_xpath_object_first(VALUE self) {
-  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+static VALUE
+rxml_xpath_object_first(VALUE self) {
+  if ( rxml_xpath_object_empty_q(self) == Qtrue )
     return Qnil;
   
-  return ruby_xml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),0);
+  return rxml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),0);
 }
 
 /*
@@ -220,12 +206,12 @@ ruby_xml_xpath_object_first(VALUE self) {
  *
  * array index into set of nodes
  */
-VALUE
-ruby_xml_xpath_object_aref(VALUE self, VALUE aref) {
-  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+static VALUE
+rxml_xpath_object_aref(VALUE self, VALUE aref) {
+  if ( rxml_xpath_object_empty_q(self) == Qtrue )
     return Qnil;
 
-  return ruby_xml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),
+  return rxml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),
 				      NUM2INT(aref));
 }
 
@@ -235,11 +221,11 @@ ruby_xml_xpath_object_aref(VALUE self, VALUE aref) {
  * 
  * Obtain the length of the nodesetval node list.
  */
-VALUE
-ruby_xml_xpath_object_length(VALUE self) {
+static VALUE
+rxml_xpath_object_length(VALUE self) {
   xmlXPathObjectPtr xpop;
 
-  if (ruby_xml_xpath_object_empty_q(self) == Qtrue)
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
     return INT2FIX(0);
 
   Data_Get_Struct(self,xmlXPathObject,xpop);
@@ -266,8 +252,8 @@ ruby_xml_xpath_object_length(VALUE self) {
  * * XML::XPath::USERS
  * * XML::XPath::XSLT_TREE 
  */
-VALUE
-ruby_xml_xpath_object_get_type(VALUE self)
+static VALUE
+rxml_xpath_object_get_type(VALUE self)
 {
   xmlXPathObjectPtr xpop;
 
@@ -283,8 +269,8 @@ ruby_xml_xpath_object_get_type(VALUE self)
  * 
  * Returns the original XPath expression as a string.
  */
-VALUE
-ruby_xml_xpath_object_string(VALUE self)
+static VALUE
+rxml_xpath_object_string(VALUE self)
 {
   xmlXPathObjectPtr xpop;
 
@@ -303,8 +289,8 @@ ruby_xml_xpath_object_string(VALUE self)
  * Dump libxml debugging information to stdout.
  * Requires Libxml be compiled with debugging enabled.
  */
-VALUE
-ruby_xml_xpath_object_debug(VALUE self) {
+static VALUE
+rxml_xpath_object_debug(VALUE self) {
   xmlXPathObjectPtr xpop;
   
   #ifndef LIBXML_DEBUG_ENABLED
@@ -321,14 +307,14 @@ ruby_init_xml_xpath_object(void) {
   cXMLXPathObject = rb_define_class_under(mXPath, "Object", rb_cObject);
   rb_include_module(cXMLXPathObject, rb_mEnumerable);
   rb_define_attr(cXMLXPathObject, "context", 1, 0);
-  rb_define_method(cXMLXPathObject, "each", ruby_xml_xpath_object_each, 0);
-  rb_define_method(cXMLXPathObject, "xpath_type", ruby_xml_xpath_object_get_type, 0);
-  rb_define_method(cXMLXPathObject, "empty?", ruby_xml_xpath_object_empty_q, 0);
-  rb_define_method(cXMLXPathObject, "first", ruby_xml_xpath_object_first, 0);
-  rb_define_method(cXMLXPathObject, "length", ruby_xml_xpath_object_length, 0);
-  rb_define_method(cXMLXPathObject, "size", ruby_xml_xpath_object_length, 0);
-  rb_define_method(cXMLXPathObject, "to_a", ruby_xml_xpath_object_to_a, 0);
-  rb_define_method(cXMLXPathObject, "[]", ruby_xml_xpath_object_aref, 1);
-  rb_define_method(cXMLXPathObject, "string", ruby_xml_xpath_object_string, 0);
-  rb_define_method(cXMLXPathObject, "debug", ruby_xml_xpath_object_debug, 0);
+  rb_define_method(cXMLXPathObject, "each", rxml_xpath_object_each, 0);
+  rb_define_method(cXMLXPathObject, "xpath_type", rxml_xpath_object_get_type, 0);
+  rb_define_method(cXMLXPathObject, "empty?", rxml_xpath_object_empty_q, 0);
+  rb_define_method(cXMLXPathObject, "first", rxml_xpath_object_first, 0);
+  rb_define_method(cXMLXPathObject, "length", rxml_xpath_object_length, 0);
+  rb_define_method(cXMLXPathObject, "size", rxml_xpath_object_length, 0);
+  rb_define_method(cXMLXPathObject, "to_a", rxml_xpath_object_to_a, 0);
+  rb_define_method(cXMLXPathObject, "[]", rxml_xpath_object_aref, 1);
+  rb_define_method(cXMLXPathObject, "string", rxml_xpath_object_string, 0);
+  rb_define_method(cXMLXPathObject, "debug", rxml_xpath_object_debug, 0);
 }

data/ext/libxml/ruby_xml_xpath_object.h

@@ -1,22 +1,11 @@
 /* $Id $ */
 
-#ifndef __RUBY_XML_XPATH_OBJECT__
-#define __RUBY_XML_XPATH_OBJECT__
+#ifndef __rxml_XPATH_OBJECT__
+#define __rxml_XPATH_OBJECT__
 
 extern VALUE cXMLXPathObject;
 
-typedef struct ruby_xml_xpath_object_s {
-  xmlXPathObjectPtr xpop;
-} ruby_xml_xpath_object;
-
 void ruby_init_xml_xpath_object(void);
-VALUE ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop);
-
-VALUE ruby_xml_xpath_object_first(VALUE self);
-VALUE ruby_xml_xpath_object_to_a(VALUE self);
-VALUE ruby_xml_xpath_object_each(VALUE self);
-VALUE ruby_xml_xpath_object_empty_q(VALUE self);
-VALUE ruby_xml_xpath_object_first(VALUE self);
-VALUE ruby_xml_xpath_object_length(VALUE self);
+VALUE rxml_xpath_object_wrap(xmlXPathObjectPtr xpop);
 
 #endif

data/ext/libxml/ruby_xml_xpointer.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpointer.c 566 2008-11-18 06:53:36Z cfis $ */
+/* $Id: ruby_xml_xpointer.c 612 2008-11-21 08:01:29Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -16,8 +16,8 @@ VALUE cXMLXPointer;
 */
 
 
-VALUE
-ruby_xml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
+static VALUE
+rxml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
 #ifdef LIBXML_XPTR_ENABLED
   xmlNodePtr xnode;
   xmlXPathContextPtr xctxt;
@@ -39,9 +39,9 @@ ruby_xml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
 
   xpop = xmlXPtrEval((xmlChar*)StringValuePtr(xptr_str), xctxt);
   if (!xpop)
-    ruby_xml_raise(&xmlLastError);
+    rxml_raise(&xmlLastError);
 
-  result = ruby_xml_xpath_object_wrap(xpop);
+  result = rxml_xpath_object_wrap(xpop);
   rb_iv_set(result, "@context", context);
   
   return(result);
@@ -51,10 +51,9 @@ ruby_xml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
 #endif
 }
 
-
 VALUE
-ruby_xml_xpointer_point2(VALUE node, VALUE xptr_str) {
-  return(ruby_xml_xpointer_point(cXMLXPointer, node, xptr_str));
+rxml_xpointer_point2(VALUE node, VALUE xptr_str) {
+  return(rxml_xpointer_point(cXMLXPointer, node, xptr_str));
 }
 
 
@@ -65,8 +64,8 @@ ruby_xml_xpointer_point2(VALUE node, VALUE xptr_str) {
  * Create an xpath representing the range between the supplied
  * start and end node.
  */
-VALUE
-ruby_xml_xpointer_range(VALUE class, VALUE rstart, VALUE rend) {
+static VALUE
+rxml_xpointer_range(VALUE class, VALUE rstart, VALUE rend) {
 #ifdef LIBXML_XPTR_ENABLED
   xmlNodePtr start, end;
   VALUE rxxp;
@@ -89,7 +88,7 @@ ruby_xml_xpointer_range(VALUE class, VALUE rstart, VALUE rend) {
   if (xpath == NULL)
     rb_fatal("You shouldn't be able to have this happen");
 
-  rxxp = ruby_xml_xpath_object_wrap(xpath);
+  rxxp = rxml_xpath_object_wrap(xpath);
   return(rxxp);
 #else
   rb_warn("libxml was compiled without XPointer support");
@@ -106,5 +105,5 @@ ruby_xml_xpointer_range(VALUE class, VALUE rstart, VALUE rend) {
 void
 ruby_init_xml_xpointer(void) {
   cXMLXPointer = rb_define_class_under(mXML, "XPointer", rb_cObject);
-  rb_define_singleton_method(cXMLXPointer, "range", ruby_xml_xpointer_range, 2);
+  rb_define_singleton_method(cXMLXPointer, "range", rxml_xpointer_range, 2);
 }

data/ext/libxml/ruby_xml_xpointer.h

@@ -1,14 +1,14 @@
-/* $Id: ruby_xml_xpointer.h 39 2006-02-21 20:40:16Z roscopeco $ */
+/* $Id: ruby_xml_xpointer.h 614 2008-11-22 08:04:39Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_XPOINTER__
-#define __RUBY_XML_XPOINTER__
+#ifndef __rxml_XPOINTER__
+#define __rxml_XPOINTER__
 
 extern VALUE cXMLXPointer;
 extern VALUE eXMLXPointerInvalidExpression;
 
-typedef struct ruby_xml_xpointer {
+typedef struct rxml_xpointer {
   VALUE xd;
   VALUE ctxt;
   /*
@@ -18,10 +18,8 @@ typedef struct ruby_xml_xpointer {
    *
    * I also need an xpointer data struct type.
   */
-} ruby_xml_xpointer;
+} rxml_xpointer;
 
-VALUE ruby_xml_xpointer_point(VALUE class, VALUE node, VALUE xptr_string);
-VALUE ruby_xml_xpointer_point2(VALUE node, VALUE xptr_string);
 void ruby_init_xml_xpointer(void);
 
 #endif