libxml-ruby 0.9.4-x86-mswin32-60 → 0.9.5-x86-mswin32-60

data/ext/libxml/ruby_xml_xpath_expression.c

@@ -8,8 +8,8 @@
 
 /*
  * Document-class: LibXML::XML::XPath::Expression
- * 
- * The XML::XPath::Expression class is used to compile  
+ *
+ * The XML::XPath::Expression class is used to compile
  * XPath expressions so they can be parsed only once
  * but reused multiple times.
  *
@@ -23,47 +23,47 @@
 
 VALUE cXMLXPathExpression;
 
-static void
-rxml_xpath_expression_free(xmlXPathCompExprPtr expr) {
+static void rxml_xpath_expression_free(xmlXPathCompExprPtr expr)
+{
   xmlXPathFreeCompExpr(expr);
 }
 
-static VALUE
-rxml_xpath_expression_alloc(VALUE klass) {
-  return Data_Wrap_Struct(cXMLXPathExpression,
-						  NULL,
-						  rxml_xpath_expression_free,
-						  NULL);
+static VALUE rxml_xpath_expression_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(cXMLXPathExpression, NULL,
+      rxml_xpath_expression_free, NULL);
 }
 
 /* call-seq:
  *    XPath::Expression.new(expression) -> XPath::Expression
- * 
- * Compiled XPatch expression. Work faster when find called many times 
+ *
+ * Compiled XPatch expression. Work faster when find called many times
  * same expression.
  *
  *  doc = XML::Document.string('<header><first>hi</first></header>')
  *  expr = XPath::Expression.new('//first')
  *  nodes = doc.find(expr)
  */
-static VALUE
-rxml_xpath_expression_initialize(VALUE self, VALUE expression) {
-  xmlXPathCompExprPtr compexpr = xmlXPathCompile(StringValueCStr(expression));  
+static VALUE rxml_xpath_expression_initialize(VALUE self, VALUE expression)
+{
+  xmlXPathCompExprPtr compexpr = xmlXPathCompile(StringValueCStr(expression));
 
-  if (compexpr == NULL) {
-	  xmlErrorPtr xerror = xmlGetLastError();
-	  rxml_raise(xerror);
+  if (compexpr == NULL)
+  {
+    xmlErrorPtr xerror = xmlGetLastError();
+    rxml_raise(xerror);
   }
 
-  DATA_PTR(self) = compexpr;
+  DATA_PTR( self) = compexpr;
   return self;
 }
 
-void
-ruby_init_xml_xpath_expression(void) {
+void ruby_init_xml_xpath_expression(void)
+{
   cXMLXPathExpression = rb_define_class_under(mXPath, "Expression", rb_cObject);
   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", rxml_xpath_expression_initialize, 1);
+  rb_define_singleton_method(cXMLXPathExpression, "compile",
+      rb_class_new_instance, 1);
+  rb_define_method(cXMLXPathExpression, "initialize",
+      rxml_xpath_expression_initialize, 1);
 }

data/ext/libxml/ruby_xml_xpath_object.c

@@ -6,14 +6,12 @@
  * Document-class: LibXML::XML::XPath::Object
  *
  * A collection of nodes returned from the evaluation of an XML::XPath
- * or XML::XPointer expression. 
+ * or XML::XPointer expression.
  *
  */
 VALUE cXMLXPathObject;
 
-
-static xmlDocPtr
-rxml_xpath_object_doc(xmlXPathObjectPtr xpop)
+static xmlDocPtr rxml_xpath_object_doc(xmlXPathObjectPtr xpop)
 {
   xmlDocPtr result = NULL;
   xmlNodePtr *nodes = NULL;
@@ -32,117 +30,114 @@ rxml_xpath_object_doc(xmlXPathObjectPtr xpop)
   return (*nodes)->doc;
 }
 
-static void
-rxml_xpath_object_mark(xmlXPathObjectPtr xpop)
+static void rxml_xpath_object_mark(xmlXPathObjectPtr xpop)
 {
   int i;
 
-  if ( xpop->type == XPATH_NODESET && xpop->nodesetval != NULL ) 
+  if (xpop->type == XPATH_NODESET && xpop->nodesetval != NULL)
   {
     xmlDocPtr xdoc = rxml_xpath_object_doc(xpop);
     if (xdoc && xdoc->_private)
-      rb_gc_mark((VALUE)xdoc->_private);
+      rb_gc_mark((VALUE) xdoc->_private);
 
-    for (i=0; i<xpop->nodesetval->nodeNr; i++) 
+    for (i = 0; i < xpop->nodesetval->nodeNr; i++)
     {
       if (xpop->nodesetval->nodeTab[i]->_private)
-        rb_gc_mark((VALUE)xpop->nodesetval->nodeTab[i]->_private);
+        rb_gc_mark((VALUE) xpop->nodesetval->nodeTab[i]->_private);
     }
   }
 }
 
-static void
-rxml_xpath_object_free(xmlXPathObjectPtr xpop)
+static void rxml_xpath_object_free(xmlXPathObjectPtr xpop)
 {
   /* Now free the xpath result but not underlying nodes
-     since those belong to the document. */
+   since those belong to the document. */
   xmlXPathFreeNodeSetList(xpop);
 }
 
-VALUE
-rxml_xpath_object_wrap(xmlXPathObjectPtr xpop)
+VALUE rxml_xpath_object_wrap(xmlXPathObjectPtr xpop)
 {
   VALUE rval;
 
-  if ( xpop==NULL )
+  if (xpop == NULL)
     return Qnil;
 
-  switch(xpop->type) {
+  switch (xpop->type)
+  {
   case XPATH_NODESET:
-    rval = Data_Wrap_Struct(cXMLXPathObject,
-                            rxml_xpath_object_mark,
-                            rxml_xpath_object_free,
-                            xpop);
-  
+    rval = Data_Wrap_Struct(cXMLXPathObject, rxml_xpath_object_mark,
+        rxml_xpath_object_free, xpop);
+
     break;
   case XPATH_BOOLEAN:
     if (xpop->boolval != 0)
-      rval=Qtrue;
+      rval = Qtrue;
     else
-      rval=Qfalse;
- 
+      rval = Qfalse;
+
     xmlXPathFreeObject(xpop);
     break;
   case XPATH_NUMBER:
-    rval=rb_float_new(xpop->floatval);
- 
+    rval = rb_float_new(xpop->floatval);
+
     xmlXPathFreeObject(xpop);
     break;
   case XPATH_STRING:
-    rval=rb_str_new2(xpop->stringval);
- 
+    rval = rb_str_new2(xpop->stringval);
+
     xmlXPathFreeObject(xpop);
     break;
   default:
     xmlXPathFreeObject(xpop);
-    rval=Qnil;
+    rval = Qnil;
   }
   return rval;
 }
 
-static VALUE
-rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
+static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos)
+{
 
-  if (apos < 0 )
-    apos=xpop->nodesetval->nodeNr+apos;
+  if (apos < 0)
+    apos = xpop->nodesetval->nodeNr + apos;
 
-  if (apos < 0 || apos+1 > xpop->nodesetval->nodeNr )
+  if (apos < 0 || apos + 1 > xpop->nodesetval->nodeNr)
     return Qnil;
 
-  switch(xpop->nodesetval->nodeTab[apos]->type) {
+  switch (xpop->nodesetval->nodeTab[apos]->type)
+  {
   case XML_ATTRIBUTE_NODE:
-    return rxml_attr_wrap((xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
+    return rxml_attr_wrap((xmlAttrPtr) xpop->nodesetval->nodeTab[apos]);
     break;
   default:
-    return rxml_node2_wrap(cXMLNode,
-			       xpop->nodesetval->nodeTab[apos]);
+    return rxml_node_wrap(cXMLNode, xpop->nodesetval->nodeTab[apos]);
   }
 }
 
 /*
  * call-seq:
  *    xpath_object.to_a -> [node, ..., node]
- * 
+ *
  * Obtain an array of the nodes in this set.
  */
-static VALUE
-rxml_xpath_object_to_a(VALUE self)
+static VALUE rxml_xpath_object_to_a(VALUE self)
 {
   VALUE set_ary, nodeobj;
   xmlXPathObjectPtr xpop;
   int i;
-  
-  Data_Get_Struct(self,xmlXPathObject,xpop);
+
+  Data_Get_Struct(self, xmlXPathObject, xpop);
 
   set_ary = rb_ary_new();
-  if (!((xpop->nodesetval == NULL) || (xpop->nodesetval->nodeNr == 0))) {
-    for (i = 0; i < xpop->nodesetval->nodeNr; i++) {
+  if (!((xpop->nodesetval == NULL) || (xpop->nodesetval->nodeNr == 0)))
+  {
+    for (i = 0; i < xpop->nodesetval->nodeNr; i++)
+    {
       nodeobj = rxml_xpath_object_tabref(xpop, i);
       rb_ary_push(set_ary, nodeobj);
     }
   }
-  
-  return(set_ary);
+
+  return (set_ary);
 }
 
 /*
@@ -151,39 +146,40 @@ rxml_xpath_object_to_a(VALUE self)
  *
  * Determine whether this nodeset is empty (contains no nodes).
  */
-static VALUE
-rxml_xpath_object_empty_q(VALUE self) {
+static VALUE rxml_xpath_object_empty_q(VALUE self)
+{
   xmlXPathObjectPtr xpop;
 
-  Data_Get_Struct(self,xmlXPathObject,xpop);
+  Data_Get_Struct(self, xmlXPathObject, xpop);
 
   if (xpop->type != XPATH_NODESET)
     return Qnil;
-  
-  return ( xpop->nodesetval == NULL || xpop->nodesetval->nodeNr <= 0 ) ? Qtrue : Qfalse;
+
+  return (xpop->nodesetval == NULL || xpop->nodesetval->nodeNr <= 0) ? Qtrue
+      : Qfalse;
 }
 
 /*
  * call-seq:
  *    xpath_object.each { |node| ... } -> self
- * 
+ *
  * Call the supplied block for each node in this set.
  */
-static VALUE
-rxml_xpath_object_each(VALUE self)
+static VALUE rxml_xpath_object_each(VALUE self)
 {
   xmlXPathObjectPtr xpop;
   int i;
 
-  if ( rxml_xpath_object_empty_q(self) == Qtrue )
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
     return Qnil;
 
-  Data_Get_Struct(self,xmlXPathObject,xpop);
+  Data_Get_Struct(self, xmlXPathObject, xpop);
 
-  for (i = 0; i < xpop->nodesetval->nodeNr; i++) {
-    rb_yield(rxml_xpath_object_tabref(xpop,i));
+  for (i = 0; i < xpop->nodesetval->nodeNr; i++)
+  {
+    rb_yield(rxml_xpath_object_tabref(xpop, i));
   }
-  return(self);
+  return (self);
 }
 
 /*
@@ -192,12 +188,12 @@ rxml_xpath_object_each(VALUE self)
  *
  * Returns the first node in this node set, or nil if none exist.
  */
-static VALUE
-rxml_xpath_object_first(VALUE self) {
-  if ( rxml_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 rxml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),0);
+
+  return rxml_xpath_object_tabref((xmlXPathObjectPtr) DATA_PTR(self), 0);
 }
 
 /*
@@ -206,29 +202,29 @@ rxml_xpath_object_first(VALUE self) {
  *
  * array index into set of nodes
  */
-static VALUE
-rxml_xpath_object_aref(VALUE self, VALUE aref) {
-  if ( rxml_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 rxml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),
-				      NUM2INT(aref));
+  return rxml_xpath_object_tabref((xmlXPathObjectPtr) DATA_PTR(self), NUM2INT(
+      aref));
 }
 
 /*
  * call-seq:
  *    xpath_object.length -> num
- * 
+ *
  * Obtain the length of the nodesetval node list.
  */
-static VALUE
-rxml_xpath_object_length(VALUE self) {
+static VALUE rxml_xpath_object_length(VALUE self)
+{
   xmlXPathObjectPtr xpop;
 
   if (rxml_xpath_object_empty_q(self) == Qtrue)
     return INT2FIX(0);
 
-  Data_Get_Struct(self,xmlXPathObject,xpop);
+  Data_Get_Struct(self, xmlXPathObject, xpop);
 
   return INT2NUM(xpop->nodesetval->nodeNr);
 }
@@ -236,11 +232,11 @@ rxml_xpath_object_length(VALUE self) {
 /*
  * call-seq:
  *    xpath_object.xpath_type -> int
- * 
- * Returns the XPath type of the result object. 
+ *
+ * Returns the XPath type of the result object.
  * Possible values are defined as constants
  * on the XML::XPath class and include:
- * 
+ *
  * * XML::XPath::UNDEFINED
  * * XML::XPath::NODESET
  * * XML::XPath::BOOLEAN
@@ -250,31 +246,28 @@ rxml_xpath_object_length(VALUE self) {
  * * XML::XPath::RANGE
  * * XML::XPath::LOCATIONSET
  * * XML::XPath::USERS
- * * XML::XPath::XSLT_TREE 
+ * * XML::XPath::XSLT_TREE
  */
-static VALUE
-rxml_xpath_object_get_type(VALUE self)
+static VALUE rxml_xpath_object_get_type(VALUE self)
 {
   xmlXPathObjectPtr xpop;
 
-  Data_Get_Struct(self,xmlXPathObject,xpop);
+  Data_Get_Struct(self, xmlXPathObject, xpop);
 
   return INT2FIX(xpop->type);
 }
 
-
 /*
  * call-seq:
  *    xpath_object.string -> String
- * 
+ *
  * Returns the original XPath expression as a string.
  */
-static VALUE
-rxml_xpath_object_string(VALUE self)
+static VALUE rxml_xpath_object_string(VALUE self)
 {
   xmlXPathObjectPtr xpop;
 
-  Data_Get_Struct(self,xmlXPathObject,xpop);
+  Data_Get_Struct(self, xmlXPathObject, xpop);
 
   if (xpop->stringval == NULL)
     return Qnil;
@@ -282,28 +275,28 @@ rxml_xpath_object_string(VALUE self)
   return rb_str_new2((const char*) xpop->stringval);
 }
 
-/* 
+/*
  * call-seq:
  *    nodes.debug -> (true|false)
- * 
+ *
  * Dump libxml debugging information to stdout.
  * Requires Libxml be compiled with debugging enabled.
  */
-static VALUE
-rxml_xpath_object_debug(VALUE self) {
+static VALUE rxml_xpath_object_debug(VALUE self)
+{
   xmlXPathObjectPtr xpop;
-  
-  #ifndef LIBXML_DEBUG_ENABLED
+
+#ifndef LIBXML_DEBUG_ENABLED
   rb_raise(rb_eTypeError, "libxml was not compiled with debug support.");
-  #endif
+#endif
 
   Data_Get_Struct(self, xmlXPathObject, xpop);
   xmlXPathDebugDumpObject(stdout, xpop, 0);
   return Qnil;
 }
 
-void
-ruby_init_xml_xpath_object(void) {
+void 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);