libxml-ruby 0.9.6-x86-mswin32-60 → 0.9.7-x86-mswin32-60

data/ext/libxml/ruby_xml_sax2_handler.c

@@ -0,0 +1,322 @@
+/* $Id: ruby_xml_sax_parser.c 682 2008-12-09 05:31:13Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_sax2_handler.h"
+
+
+VALUE cbidOnCdataBlock;
+VALUE cbidOnCharacters;
+VALUE cbidOnComment;
+VALUE cbidOnEndDocument;
+VALUE cbidOnEndElement;
+VALUE cbidOnEndElementNs;
+VALUE cbidOnExternalSubset;
+VALUE cbidOnHasExternalSubset;
+VALUE cbidOnHasInternalSubset;
+VALUE cbidOnInternalSubset;
+VALUE cbidOnIsStandalone;
+VALUE cbidOnError;
+VALUE cbidOnProcessingInstruction;
+VALUE cbidOnReference;
+VALUE cbidOnStartElement;
+VALUE cbidOnStartElementNs;
+VALUE cbidOnStartDocument;
+
+/* ======  Callbacks  =========== */
+static void cdata_block_callback(void *ctx,
+const char *value, int len)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnCdataBlock,1,rb_str_new(value, len));
+  }
+}
+
+static void characters_callback(void *ctx,
+const char *chars, int len)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    VALUE rchars = rb_str_new(chars, len);
+    rb_funcall(handler, cbidOnCharacters, 1, rchars);
+  }
+}
+
+static void comment_callback(void *ctx,
+const char *msg)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnComment,1,rb_str_new2(msg));
+  }
+}
+
+static void end_document_callback(void *ctx)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnEndDocument, 0);
+  }
+}
+
+static void end_element_ns_callback(void *ctx,
+  					                        const xmlChar *xlocalname, const xmlChar *xprefix, const xmlChar *xURI)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler == Qnil)
+    return;
+
+  /* Call end element for old-times sake */
+  if (rb_respond_to(handler, cbidOnEndElement))
+  {
+    VALUE name;
+    if (xprefix)
+    {
+      name = rb_str_new2(xprefix);
+      rb_str_cat2(name, ":"); 
+      rb_str_cat2(name, xlocalname); 
+    }
+    else
+    {
+      name = rb_str_new2(xlocalname);
+    }
+    rb_funcall(handler, cbidOnEndElement, 1, name);
+  }
+
+  rb_funcall(handler, cbidOnEndElementNs, 3, 
+             rb_str_new2(xlocalname),
+             xprefix ? rb_str_new2(xprefix) : Qnil,
+             xURI ? rb_str_new2(xURI) : Qnil);
+}
+
+static void external_subset_callback(void *ctx, const char *name, const char *extid, const char *sysid)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    VALUE rname = name ? rb_str_new2(name) : Qnil;
+    VALUE rextid = extid ? rb_str_new2(extid) : Qnil;
+    VALUE rsysid = sysid ? rb_str_new2(sysid) : Qnil;
+    rb_funcall(handler, cbidOnExternalSubset, 3, rname, rextid, rsysid);
+  }
+}
+
+static void has_external_subset_callback(void *ctx)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnHasExternalSubset, 0);
+  }
+}
+
+static void has_internal_subset_callback(void *ctx)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnHasInternalSubset, 0);
+  }
+}
+
+static void internal_subset_callback(void *ctx, const char *name, const char *extid, const char *sysid)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    VALUE rname = name ? rb_str_new2(name) : Qnil;
+    VALUE rextid = extid ? rb_str_new2(extid) : Qnil;
+    VALUE rsysid = sysid ? rb_str_new2(sysid) : Qnil;
+    rb_funcall(handler, cbidOnInternalSubset, 3, rname, rextid, rsysid);
+  }
+}
+
+static void is_standalone_callback(void *ctx)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnIsStandalone,0);
+  }
+}
+
+static void processing_instruction_callback(void *ctx, const char *target, const char *data)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    VALUE rtarget = target ? rb_str_new2(target) : Qnil;
+    VALUE rdata = data ? rb_str_new2(data) : Qnil;
+    rb_funcall(handler, cbidOnProcessingInstruction, 2, rtarget, rdata);
+  }
+}
+
+static void reference_callback(void *ctx, const char *name)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnReference,1,rb_str_new2(name));
+  }
+}
+
+static void start_document_callback(void *ctx)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    rb_funcall(handler, cbidOnStartDocument, 0);
+  }
+}
+
+static void start_element_ns_callback(void *ctx, 
+                                      const xmlChar *xlocalname, const xmlChar *xprefix, const xmlChar *xURI,
+                            					int nb_namespaces, const xmlChar **xnamespaces,
+					                            int nb_attributes, int nb_defaulted, const xmlChar **xattributes)
+{
+  VALUE handler = (VALUE) ctx;
+  VALUE attributes = rb_hash_new();
+  VALUE namespaces = rb_hash_new();
+
+  if (handler == Qnil)
+    return;
+
+  if (xattributes)
+  {
+    /* Each attribute is an array of [localname, prefix, URI, value, end] */
+    int i;
+    for (i = 0;i < nb_attributes * 5; i+=5) 
+    {
+      VALUE attrName = rb_str_new2(xattributes[i+0]);
+      VALUE attrValue = rb_str_new(xattributes[i+3], xattributes[i+4] - xattributes[i+3]);
+      /* VALUE attrPrefix = xattributes[i+1] ? rb_str_new2(xattributes[i+1]) : Qnil;
+         VALUE attrURI = xattributes[i+2] ? rb_str_new2(xattributes[i+2]) : Qnil; */
+
+      rb_hash_aset(attributes, attrName, attrValue);
+    }
+  }
+
+  if (xnamespaces)
+  {
+    int i;
+    for (i = 0;i < nb_namespaces * 2; i+=2) 
+    {
+      VALUE nsPrefix = xnamespaces[i+0] ? rb_str_new2(xnamespaces[i+0]) : Qnil;
+      VALUE nsURI = xnamespaces[i+1] ? rb_str_new2(xnamespaces[i+1]) : Qnil;
+      rb_hash_aset(attributes, nsPrefix, nsURI);
+    }
+  }
+
+  /* Call start element for old-times sake */
+  if (rb_respond_to(handler, cbidOnStartElement))
+  {
+    VALUE name;
+    if (xprefix)
+    {
+      name = rb_str_new2(xprefix);
+      rb_str_cat2(name, ":"); 
+      rb_str_cat2(name, xlocalname); 
+    }
+    else
+    {
+      name = rb_str_new2(xlocalname);
+    }
+    rb_funcall(handler, cbidOnStartElement, 2, name, attributes);
+  }
+
+  rb_funcall(handler, cbidOnStartElementNs, 5, 
+             rb_str_new2(xlocalname),
+             attributes,
+             xprefix ? rb_str_new2(xprefix) : Qnil,
+             xURI ? rb_str_new2(xURI) : Qnil,
+             namespaces);
+}
+
+static void structured_error_callback(void *ctx, xmlErrorPtr xerror)
+{
+  VALUE handler = (VALUE) ctx;
+
+  if (handler != Qnil)
+  {
+    VALUE error = rxml_error_wrap(xerror);
+    rb_funcall(handler, cbidOnError, 1, error);
+  }
+}
+
+/* ======  Handler  =========== */
+xmlSAXHandler rxml_sax_handler = {
+  (internalSubsetSAXFunc) internal_subset_callback,
+  (isStandaloneSAXFunc) is_standalone_callback,
+  (hasInternalSubsetSAXFunc) has_internal_subset_callback,
+  (hasExternalSubsetSAXFunc) has_external_subset_callback,
+  0, /* resolveEntity */
+  0, /* getEntity */
+  0, /* entityDecl */
+  0, /* notationDecl */
+  0, /* attributeDecl */
+  0, /* elementDecl */
+  0, /* unparsedEntityDecl */
+  0, /* setDocumentLocator */
+  (startDocumentSAXFunc) start_document_callback,
+  (endDocumentSAXFunc) end_document_callback,
+  0, /* Use start_element_ns_callback instead */
+  0, /* Use end_element_ns_callback instead */
+  (referenceSAXFunc) reference_callback,
+  (charactersSAXFunc) characters_callback,
+  0, /* ignorableWhitespace */
+  (processingInstructionSAXFunc) processing_instruction_callback,
+  (commentSAXFunc) comment_callback,
+  0, /* xmlStructuredErrorFunc is used instead */
+  0, /* xmlStructuredErrorFunc is used instead */
+  0, /* xmlStructuredErrorFunc is used instead */
+  0, /* xmlGetParameterEntity */
+  (cdataBlockSAXFunc) cdata_block_callback,
+  (externalSubsetSAXFunc) external_subset_callback,
+  XML_SAX2_MAGIC, /* force SAX2 */
+  0, /* _private */
+  (startElementNsSAX2Func) start_element_ns_callback,
+  (endElementNsSAX2Func) end_element_ns_callback,
+  (xmlStructuredErrorFunc) structured_error_callback
+};
+
+void ruby_init_xml_sax2_handler(void)
+{
+
+  /* SaxCallbacks */
+  cbidOnCdataBlock =            rb_intern("on_cdata_block");
+  cbidOnCharacters =            rb_intern("on_characters");
+  cbidOnComment =               rb_intern("on_comment");
+  cbidOnEndDocument =           rb_intern("on_end_document");
+  cbidOnEndElement =            rb_intern("on_end_element");
+  cbidOnEndElementNs =          rb_intern("on_end_element_ns");
+  cbidOnError =                 rb_intern("on_error");
+  cbidOnExternalSubset =        rb_intern("on_external_subset");
+  cbidOnHasExternalSubset =     rb_intern("on_has_external_subset");
+  cbidOnHasInternalSubset =     rb_intern("on_has_internal_subset");
+  cbidOnInternalSubset =        rb_intern("on_internal_subset");
+  cbidOnIsStandalone =          rb_intern("on_is_standalone");
+  cbidOnProcessingInstruction = rb_intern("on_processing_instruction");
+  cbidOnReference =             rb_intern("on_reference");
+  cbidOnStartElement =          rb_intern("on_start_element");
+  cbidOnStartElementNs =        rb_intern("on_start_element_ns");
+  cbidOnStartDocument =         rb_intern("on_start_document");
+}

data/ext/libxml/ruby_xml_sax2_handler.h

@@ -0,0 +1,12 @@
+/* $Id: ruby_xml_sax_parser.h 666 2008-12-07 00:16:50Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_SAX2_HANDLER__
+#define __RXML_SAX2_HANDLER__
+
+extern xmlSAXHandler rxml_sax_handler;
+
+void ruby_init_xml_sax2_handler(void);
+
+#endif

data/ext/libxml/ruby_xml_sax_parser.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_sax_parser.c 650 2008-11-30 03:40:22Z cfis $ */
+/* $Id: ruby_xml_sax_parser.c 684 2008-12-13 00:34:28Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -36,31 +36,12 @@
  */
 
 VALUE cXMLSaxParser;
-VALUE mXMLSaxParserCallbacks;
 
 static ID INPUT_ATTR;
 static ID CALLBACKS_ATTR;
 
-VALUE cbidOnInternalSubset;
-VALUE cbidOnIsStandalone;
-VALUE cbidOnHasInternalSubset;
-VALUE cbidOnHasExternalSubset;
-VALUE cbidOnStartDocument;
-VALUE cbidOnEndDocument;
-VALUE cbidOnStartElement;
-VALUE cbidOnEndElement;
-VALUE cbidOnReference;
-VALUE cbidOnCharacters;
-VALUE cbidOnProcessingInstruction;
-VALUE cbidOnComment;
-VALUE cbidOnXmlParserWarning;
-VALUE cbidOnXmlParserError;
-VALUE cbidOnXmlParserFatalError;
-VALUE cbidOnCdataBlock;
-VALUE cbidOnExternalSubset;
-
-#include "sax_parser_callbacks.inc"
 
+/* ======  Parser  =========== */
 /*
  * call-seq:
  *    sax_parser.initialize -> sax_parser
@@ -77,26 +58,29 @@ static VALUE rxml_sax_parser_initialize(VALUE self)
 /* Parsing data sources */
 static int rxml_sax_parser_parse_file(VALUE self, VALUE input)
 {
+  VALUE handler = rb_ivar_get(self, CALLBACKS_ATTR);
   VALUE file = rb_ivar_get(input, FILE_ATTR);
-  return xmlSAXUserParseFile((xmlSAXHandlerPtr) & rxml_sax_hander_struct,
-      (void *) self, StringValuePtr(file));
+  return xmlSAXUserParseFile((xmlSAXHandlerPtr) &rxml_sax_handler,
+      (void *) handler, StringValuePtr(file));
 }
 
 static int rxml_sax_parser_parse_string(VALUE self, VALUE input)
 {
+  VALUE handler = rb_ivar_get(self, CALLBACKS_ATTR);
   VALUE str = rb_ivar_get(input, STRING_ATTR);
-  return xmlSAXUserParseMemory((xmlSAXHandlerPtr) & rxml_sax_hander_struct,
-      (void *) self, StringValuePtr(str), RSTRING_LEN(str));
+  return xmlSAXUserParseMemory((xmlSAXHandlerPtr) &rxml_sax_handler,
+      (void *) handler, StringValuePtr(str), RSTRING_LEN(str));
 }
 
 static int rxml_sax_parser_parse_io(VALUE self, VALUE input)
 {
+  VALUE handler = rb_ivar_get(self, CALLBACKS_ATTR);
   VALUE io = rb_ivar_get(input, IO_ATTR);
   VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
   xmlCharEncoding xmlEncoding = NUM2INT(encoding);
   xmlParserCtxtPtr ctxt =
-      xmlCreateIOParserCtxt((xmlSAXHandlerPtr) & rxml_sax_hander_struct,
-          (void *) self, (xmlInputReadCallback) rxml_read_callback, NULL,
+      xmlCreateIOParserCtxt((xmlSAXHandlerPtr) &rxml_sax_handler,
+          (void *) handler, (xmlInputReadCallback) rxml_read_callback, NULL,
           (void *) io, xmlEncoding);
   return xmlParseDocument(ctxt);
 }
@@ -153,23 +137,4 @@ void ruby_init_xml_sax_parser(void)
   /* Instance Methods */
   rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, 0);
   rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
-
-  /* SaxCallbacks */
-  cbidOnInternalSubset = rb_intern("on_internal_subset");
-  cbidOnIsStandalone = rb_intern("on_is_standalone");
-  cbidOnHasInternalSubset = rb_intern("on_has_internal_subset");
-  cbidOnHasExternalSubset = rb_intern("on_has_external_subset");
-  cbidOnStartDocument = rb_intern("on_start_document");
-  cbidOnEndDocument = rb_intern("on_end_document");
-  cbidOnStartElement = rb_intern("on_start_element");
-  cbidOnEndElement = rb_intern("on_end_element");
-  cbidOnReference = rb_intern("on_reference");
-  cbidOnCharacters = rb_intern("on_characters");
-  cbidOnProcessingInstruction = rb_intern("on_processing_instruction");
-  cbidOnComment = rb_intern("on_comment");
-  cbidOnXmlParserWarning = rb_intern("on_parser_warning");
-  cbidOnXmlParserError = rb_intern("on_parser_error");
-  cbidOnXmlParserFatalError = rb_intern("on_parser_fatal_error");
-  cbidOnCdataBlock = rb_intern("on_cdata_block");
-  cbidOnExternalSubset = rb_intern("on_external_subset");
-}
+}

data/ext/libxml/ruby_xml_xpath_context.c

@@ -1,354 +1,354 @@
-/* $Id: ruby_xml_xpath_context.c 673 2008-12-08 06:33:23Z cfis $ */
-
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include "ruby_libxml.h"
-#include "ruby_xml_xpath_context.h"
-#include "ruby_xml_xpath_expression.h"
-#include <st.h>
-
-/*
- * Document-class: LibXML::XML::XPath::Context
- *
- * The XML::XPath::Context class is used to evaluate XPath
- * expressions.  Generally, you should not directly use this class,
- * but instead use the XML::Document#find and XML::Node#find methods.
- *
- *  doc = XML::Document.string('<header>content</header>')
- *  context = XPath::Context.new(doc)
- *  context.node = doc.root
- *  context.register_namespaces_from_node(doc.root)
- *  nodes = context.find('/header')
- */
-
-VALUE cXMLXPathContext;
-
-static void rxml_xpath_context_free(xmlXPathContextPtr ctxt)
-{
-  xmlXPathFreeContext(ctxt);
-}
-
-static VALUE rxml_xpath_context_alloc(VALUE klass)
-{
-  return Data_Wrap_Struct(cXMLXPathContext, NULL, rxml_xpath_context_free, NULL);
-}
-
-/* call-seq:
- *    XPath::Context.new(node) -> XPath::Context
- *
- * Creates a new XPath context for the specified document.  The
- * context can then be used to evaluate an XPath expression.
- *
- *  doc = XML::Document.string('<header><first>hi</first></header>')
- *  context = XPath::Context.new(doc)
- *  nodes = XPath::Object.new('//first', context)
- *  nodes.length == 1
- */
-static VALUE rxml_xpath_context_initialize(VALUE self, VALUE node)
-{
-  xmlDocPtr xdoc;
-  VALUE document;
-
-  if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
-  {
-    document = rb_funcall(node, rb_intern("doc"), 0);
-    if (NIL_P(document))
-    rb_raise(rb_eTypeError, "Supplied node must belong to a document.");
-  }
-  else if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
-  {
-    document = node;
-  }
-  else
-  {
-    rb_raise(rb_eTypeError, "Supplied argument must be a document or node.");
-  }
-
-  Data_Get_Struct(document, xmlDoc, xdoc);
-  DATA_PTR(self) = xmlXPathNewContext(xdoc);
-
-  /* Save the doc as an attribute, this will expose it to Ruby's GC. */
-  rb_iv_set(self, "@doc", document);
-
-  return self;
-}
-
-/*
- * call-seq:
- *    context.register_namespace(prefix, uri) -> (true|false)
- *
- * Register the specified namespace URI with the specified prefix
- * in this context.
-
- *   context.register_namespace('xi', 'http://www.w3.org/2001/XInclude')
- */
-static VALUE rxml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri)
-{
-  xmlXPathContextPtr ctxt;
-  Data_Get_Struct(self, xmlXPathContext, ctxt);
-
-  /* Prefix could be a symbol. */
-  prefix = rb_obj_as_string(prefix);
-  
-  if (xmlXPathRegisterNs(ctxt, (xmlChar*) StringValuePtr(prefix),
-      (xmlChar*) StringValuePtr(uri)) == 0)
-  {
-    return (Qtrue);
-  }
-  else
-  {
-    /* Should raise an exception, IMHO (whose?, why shouldnt it? -danj)*/
-    rb_warning("register namespace failed");
-    return (Qfalse);
-  }
-}
-
-/* call-seq:
- *    context.register_namespaces_from_node(node) -> self
- *
- * Helper method to read in namespaces defined on a node.
- *
- *  doc = XML::Document.string('<header><first>hi</first></header>')
- *  context = XPath::Context.new(doc)
- *  context.register_namespaces_from_node(doc.root)
- */
-static VALUE rxml_xpath_context_register_namespaces_from_node(VALUE self,
-    VALUE node)
-{
-  xmlXPathContextPtr xctxt;
-  xmlNodePtr xnode;
-  xmlNsPtr *xnsArr;
-
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
-
-  if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
-  {
-    xmlDocPtr xdoc;
-    Data_Get_Struct(node, xmlDoc, xdoc);
-    xnode = xmlDocGetRootElement(xdoc);
-  }
-  else if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
-  {
-    Data_Get_Struct(node, xmlNode, xnode);
-  }
-  else
-  {
-    rb_raise(rb_eTypeError, "The first argument must be a document or node.");
-  }
-
-  xnsArr = xmlGetNsList(xnode->doc, xnode);
-
-  if (xnsArr)
-  {
-    xmlNsPtr xns = *xnsArr;
-
-    while (xns)
-    {
-      /* If there is no prefix, then this is the default namespace.
-       Skip it for now. */
-      if (xns->prefix)
-      {
-        VALUE prefix = rb_str_new2((const char*)xns->prefix);
-        VALUE uri = rb_str_new2((const char*)xns->href);
-        rxml_xpath_context_register_namespace(self, prefix, uri);
-      }
-      xns = xns->next;
-    }
-    xmlFree(xnsArr);
-  }
-
-  return self;
-}
-
-static int iterate_ns_hash(st_data_t prefix, st_data_t uri, st_data_t self)
-{
-  rxml_xpath_context_register_namespace(self, prefix, uri);
-  return ST_CONTINUE;
-}
-
-/*
- * call-seq:
- *    context.register_namespaces(["prefix:uri"]) -> self
- *
- * Register the specified namespaces in this context.  There are
- * three different forms that libxml accepts.  These include
- * a string, an array of strings, or a hash table:
- *
- *   context.register_namespaces('xi:http://www.w3.org/2001/XInclude')
- *   context.register_namespaces(['xlink:http://www.w3.org/1999/xlink',
- *                                'xi:http://www.w3.org/2001/XInclude')
- *   context.register_namespaces('xlink' => 'http://www.w3.org/1999/xlink',
- *                                  'xi' => 'http://www.w3.org/2001/XInclude')
- */
-static VALUE rxml_xpath_context_register_namespaces(VALUE self, VALUE nslist)
-{
-  char *cp;
-  long i;
-  VALUE rprefix, ruri;
-
-  /* Need to loop through the 2nd argument and iterate through the
-   * list of namespaces that we want to allow */
-  switch (TYPE(nslist))
-  {
-  case T_STRING:
-    cp = strchr(StringValuePtr(nslist), (int) ':');
-    if (cp == NULL)
-    {
-      rprefix = nslist;
-      ruri = Qnil;
-    }
-    else
-    {
-      rprefix = rb_str_new(StringValuePtr(nslist), (int) ((long) cp
-          - (long) StringValuePtr(nslist)));
-      ruri = rb_str_new2(&cp[1]);
-    }
-    /* Should test the results of this */
-    rxml_xpath_context_register_namespace(self, rprefix, ruri);
-    break;
-  case T_ARRAY:
-    for (i = 0; i < RARRAY_LEN(nslist); i++)
-    {
-      rxml_xpath_context_register_namespaces(self, RARRAY_PTR(nslist)[i]);
-    }
-    break;
-  case T_HASH:
-    st_foreach(RHASH_TBL(nslist), iterate_ns_hash, self);
-    break;
-  default:
-    rb_raise(
-        rb_eArgError,
-        "Invalid argument type, only accept string, array of strings, or an array of arrays");
-  }
-  return self;
-}
-
-/*
- * call-seq:
- *    context.node = node
- *
- * Set the current node used by the XPath engine
-
- *  doc = XML::Document.string('<header><first>hi</first></header>')
- *  context.node = doc.root.first
- */
-static VALUE rxml_xpath_context_node_set(VALUE self, VALUE node)
-{
-  xmlXPathContextPtr xctxt;
-  xmlNodePtr xnode;
-
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
-  Data_Get_Struct(node, xmlNode, xnode);
-  xctxt->node = xnode;
-  return node;
-}
-
-/*
- * call-seq:
- *    context.find("xpath") -> XML::XPath::Object
- *
- * Find nodes matching the specified XPath expression
- */
-static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
-{
-  xmlXPathContextPtr xctxt;
-  xmlXPathObjectPtr xobject;
-  xmlXPathCompExprPtr xcompexpr;
-  VALUE result;
-
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
-
-  if (TYPE(xpath_expr) == T_STRING)
-  {
-    VALUE expression = rb_check_string_type(xpath_expr);
-    xobject = xmlXPathEval((xmlChar*) StringValueCStr(expression), xctxt);
-  }
-  else if (rb_obj_is_kind_of(xpath_expr, cXMLXPathExpression))
-  {
-    Data_Get_Struct(xpath_expr, xmlXPathCompExpr, xcompexpr);
-    xobject = xmlXPathCompiledEval(xcompexpr, xctxt);
-  }
-  else
-  {
-    rb_raise(rb_eTypeError,
-        "Argument should be an intance of a String or XPath::Expression");
-  }
-
-  if (xobject == NULL)
-  {
-    /* xmlLastError is different than xctxt->lastError.  Use
-     xmlLastError since it has the message set while xctxt->lastError
-     does not. */
-    xmlErrorPtr xerror = xmlGetLastError();
-    rxml_raise(xerror);
-  }
-
-  result = rxml_xpath_object_wrap(xobject);
-  rb_iv_set(result, "@context", self);
-  return result;
-}
-
-
-/*
- * call-seq:
- *    context.enable_cache(size = nil)
- *
- * Enables an XPath::Context's built-in cache.  If the cache is
- * enabled then XPath objects will be cached internally for reuse.
- * The size parameter controls sets the maximum number of XPath objects 
- * that will be cached per XPath object type (node-set, string, number,
- * boolean, and misc objects).  Set size to nil to use the default
- * cache size of 100.
- */
-static VALUE
-rxml_xpath_context_enable_cache(int argc,  VALUE *argv, VALUE self)
-{
-  xmlXPathContextPtr xctxt;
-  VALUE size;
-  int value = -1;
-
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
-
-  if (rb_scan_args(argc, argv, "01", &size) == 1)
-  {
-	  value = NUM2INT(size);
-  }
-
-  if (xmlXPathContextSetCache(xctxt, 1, value, 0) == -1)
-    rxml_raise(&xmlLastError);
-
-  return self;
-}
-
-/*
- * call-seq:
- *    context.disable_cache
- * 
- * Disables an XPath::Context's built-in cache.
- */
-static VALUE
-rxml_xpath_context_disable_cache(VALUE self) {
-  xmlXPathContextPtr xctxt;
-  Data_Get_Struct(self, xmlXPathContext, xctxt);
-
-  if (xmlXPathContextSetCache(xctxt, 0, 0, 0) == -1)
-    rxml_raise(&xmlLastError);
-
-  return self;
-}
-
-
-void ruby_init_xml_xpath_context(void)
-{
-  cXMLXPathContext = rb_define_class_under(mXPath, "Context", rb_cObject);
-  rb_define_alloc_func(cXMLXPathContext, rxml_xpath_context_alloc);
-  rb_define_attr(cXMLXPathContext, "doc", 1, 0);
-  rb_define_method(cXMLXPathContext, "initialize", rxml_xpath_context_initialize, 1);
-  rb_define_method(cXMLXPathContext, "register_namespaces", rxml_xpath_context_register_namespaces, 1);
-  rb_define_method(cXMLXPathContext, "register_namespaces_from_node", rxml_xpath_context_register_namespaces_from_node, 1);
-  rb_define_method(cXMLXPathContext, "register_namespace", rxml_xpath_context_register_namespace, 2);
-  rb_define_method(cXMLXPathContext, "node=", rxml_xpath_context_node_set, 1);
-  rb_define_method(cXMLXPathContext, "find", rxml_xpath_context_find, 1);
-  rb_define_method(cXMLXPathContext, "enable_cache", rxml_xpath_context_enable_cache, -1);
-  rb_define_method(cXMLXPathContext, "disable_cache", rxml_xpath_context_disable_cache, 0);
-}
+/* $Id: ruby_xml_xpath_context.c 673 2008-12-08 06:33:23Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xpath_context.h"
+#include "ruby_xml_xpath_expression.h"
+#include <st.h>
+
+/*
+ * Document-class: LibXML::XML::XPath::Context
+ *
+ * The XML::XPath::Context class is used to evaluate XPath
+ * expressions.  Generally, you should not directly use this class,
+ * but instead use the XML::Document#find and XML::Node#find methods.
+ *
+ *  doc = XML::Document.string('<header>content</header>')
+ *  context = XPath::Context.new(doc)
+ *  context.node = doc.root
+ *  context.register_namespaces_from_node(doc.root)
+ *  nodes = context.find('/header')
+ */
+
+VALUE cXMLXPathContext;
+
+static void rxml_xpath_context_free(xmlXPathContextPtr ctxt)
+{
+  xmlXPathFreeContext(ctxt);
+}
+
+static VALUE rxml_xpath_context_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(cXMLXPathContext, NULL, rxml_xpath_context_free, NULL);
+}
+
+/* call-seq:
+ *    XPath::Context.new(node) -> XPath::Context
+ *
+ * Creates a new XPath context for the specified document.  The
+ * context can then be used to evaluate an XPath expression.
+ *
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  context = XPath::Context.new(doc)
+ *  nodes = XPath::Object.new('//first', context)
+ *  nodes.length == 1
+ */
+static VALUE rxml_xpath_context_initialize(VALUE self, VALUE node)
+{
+  xmlDocPtr xdoc;
+  VALUE document;
+
+  if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
+  {
+    document = rb_funcall(node, rb_intern("doc"), 0);
+    if (NIL_P(document))
+    rb_raise(rb_eTypeError, "Supplied node must belong to a document.");
+  }
+  else if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
+  {
+    document = node;
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "Supplied argument must be a document or node.");
+  }
+
+  Data_Get_Struct(document, xmlDoc, xdoc);
+  DATA_PTR(self) = xmlXPathNewContext(xdoc);
+
+  /* Save the doc as an attribute, this will expose it to Ruby's GC. */
+  rb_iv_set(self, "@doc", document);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *    context.register_namespace(prefix, uri) -> (true|false)
+ *
+ * Register the specified namespace URI with the specified prefix
+ * in this context.
+
+ *   context.register_namespace('xi', 'http://www.w3.org/2001/XInclude')
+ */
+static VALUE rxml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri)
+{
+  xmlXPathContextPtr ctxt;
+  Data_Get_Struct(self, xmlXPathContext, ctxt);
+
+  /* Prefix could be a symbol. */
+  prefix = rb_obj_as_string(prefix);
+  
+  if (xmlXPathRegisterNs(ctxt, (xmlChar*) StringValuePtr(prefix),
+      (xmlChar*) StringValuePtr(uri)) == 0)
+  {
+    return (Qtrue);
+  }
+  else
+  {
+    /* Should raise an exception, IMHO (whose?, why shouldnt it? -danj)*/
+    rb_warning("register namespace failed");
+    return (Qfalse);
+  }
+}
+
+/* call-seq:
+ *    context.register_namespaces_from_node(node) -> self
+ *
+ * Helper method to read in namespaces defined on a node.
+ *
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  context = XPath::Context.new(doc)
+ *  context.register_namespaces_from_node(doc.root)
+ */
+static VALUE rxml_xpath_context_register_namespaces_from_node(VALUE self,
+    VALUE node)
+{
+  xmlXPathContextPtr xctxt;
+  xmlNodePtr xnode;
+  xmlNsPtr *xnsArr;
+
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+
+  if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
+  {
+    xmlDocPtr xdoc;
+    Data_Get_Struct(node, xmlDoc, xdoc);
+    xnode = xmlDocGetRootElement(xdoc);
+  }
+  else if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
+  {
+    Data_Get_Struct(node, xmlNode, xnode);
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "The first argument must be a document or node.");
+  }
+
+  xnsArr = xmlGetNsList(xnode->doc, xnode);
+
+  if (xnsArr)
+  {
+    xmlNsPtr xns = *xnsArr;
+
+    while (xns)
+    {
+      /* If there is no prefix, then this is the default namespace.
+       Skip it for now. */
+      if (xns->prefix)
+      {
+        VALUE prefix = rb_str_new2((const char*)xns->prefix);
+        VALUE uri = rb_str_new2((const char*)xns->href);
+        rxml_xpath_context_register_namespace(self, prefix, uri);
+      }
+      xns = xns->next;
+    }
+    xmlFree(xnsArr);
+  }
+
+  return self;
+}
+
+static int iterate_ns_hash(st_data_t prefix, st_data_t uri, st_data_t self)
+{
+  rxml_xpath_context_register_namespace(self, prefix, uri);
+  return ST_CONTINUE;
+}
+
+/*
+ * call-seq:
+ *    context.register_namespaces(["prefix:uri"]) -> self
+ *
+ * Register the specified namespaces in this context.  There are
+ * three different forms that libxml accepts.  These include
+ * a string, an array of strings, or a hash table:
+ *
+ *   context.register_namespaces('xi:http://www.w3.org/2001/XInclude')
+ *   context.register_namespaces(['xlink:http://www.w3.org/1999/xlink',
+ *                                'xi:http://www.w3.org/2001/XInclude')
+ *   context.register_namespaces('xlink' => 'http://www.w3.org/1999/xlink',
+ *                                  'xi' => 'http://www.w3.org/2001/XInclude')
+ */
+static VALUE rxml_xpath_context_register_namespaces(VALUE self, VALUE nslist)
+{
+  char *cp;
+  long i;
+  VALUE rprefix, ruri;
+
+  /* Need to loop through the 2nd argument and iterate through the
+   * list of namespaces that we want to allow */
+  switch (TYPE(nslist))
+  {
+  case T_STRING:
+    cp = strchr(StringValuePtr(nslist), (int) ':');
+    if (cp == NULL)
+    {
+      rprefix = nslist;
+      ruri = Qnil;
+    }
+    else
+    {
+      rprefix = rb_str_new(StringValuePtr(nslist), (int) ((long) cp
+          - (long) StringValuePtr(nslist)));
+      ruri = rb_str_new2(&cp[1]);
+    }
+    /* Should test the results of this */
+    rxml_xpath_context_register_namespace(self, rprefix, ruri);
+    break;
+  case T_ARRAY:
+    for (i = 0; i < RARRAY_LEN(nslist); i++)
+    {
+      rxml_xpath_context_register_namespaces(self, RARRAY_PTR(nslist)[i]);
+    }
+    break;
+  case T_HASH:
+    st_foreach(RHASH_TBL(nslist), iterate_ns_hash, self);
+    break;
+  default:
+    rb_raise(
+        rb_eArgError,
+        "Invalid argument type, only accept string, array of strings, or an array of arrays");
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *    context.node = node
+ *
+ * Set the current node used by the XPath engine
+
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  context.node = doc.root.first
+ */
+static VALUE rxml_xpath_context_node_set(VALUE self, VALUE node)
+{
+  xmlXPathContextPtr xctxt;
+  xmlNodePtr xnode;
+
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  Data_Get_Struct(node, xmlNode, xnode);
+  xctxt->node = xnode;
+  return node;
+}
+
+/*
+ * call-seq:
+ *    context.find("xpath") -> XML::XPath::Object
+ *
+ * Find nodes matching the specified XPath expression
+ */
+static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
+{
+  xmlXPathContextPtr xctxt;
+  xmlXPathObjectPtr xobject;
+  xmlXPathCompExprPtr xcompexpr;
+  VALUE result;
+
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+
+  if (TYPE(xpath_expr) == T_STRING)
+  {
+    VALUE expression = rb_check_string_type(xpath_expr);
+    xobject = xmlXPathEval((xmlChar*) StringValueCStr(expression), xctxt);
+  }
+  else if (rb_obj_is_kind_of(xpath_expr, cXMLXPathExpression))
+  {
+    Data_Get_Struct(xpath_expr, xmlXPathCompExpr, xcompexpr);
+    xobject = xmlXPathCompiledEval(xcompexpr, xctxt);
+  }
+  else
+  {
+    rb_raise(rb_eTypeError,
+        "Argument should be an intance of a String or XPath::Expression");
+  }
+
+  if (xobject == NULL)
+  {
+    /* xmlLastError is different than xctxt->lastError.  Use
+     xmlLastError since it has the message set while xctxt->lastError
+     does not. */
+    xmlErrorPtr xerror = xmlGetLastError();
+    rxml_raise(xerror);
+  }
+
+  result = rxml_xpath_object_wrap(xobject);
+  rb_iv_set(result, "@context", self);
+  return result;
+}
+
+
+/*
+ * call-seq:
+ *    context.enable_cache(size = nil)
+ *
+ * Enables an XPath::Context's built-in cache.  If the cache is
+ * enabled then XPath objects will be cached internally for reuse.
+ * The size parameter controls sets the maximum number of XPath objects 
+ * that will be cached per XPath object type (node-set, string, number,
+ * boolean, and misc objects).  Set size to nil to use the default
+ * cache size of 100.
+ */
+static VALUE
+rxml_xpath_context_enable_cache(int argc,  VALUE *argv, VALUE self)
+{
+  xmlXPathContextPtr xctxt;
+  VALUE size;
+  int value = -1;
+
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+
+  if (rb_scan_args(argc, argv, "01", &size) == 1)
+  {
+	  value = NUM2INT(size);
+  }
+
+  if (xmlXPathContextSetCache(xctxt, 1, value, 0) == -1)
+    rxml_raise(&xmlLastError);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *    context.disable_cache
+ * 
+ * Disables an XPath::Context's built-in cache.
+ */
+static VALUE
+rxml_xpath_context_disable_cache(VALUE self) {
+  xmlXPathContextPtr xctxt;
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+
+  if (xmlXPathContextSetCache(xctxt, 0, 0, 0) == -1)
+    rxml_raise(&xmlLastError);
+
+  return self;
+}
+
+
+void ruby_init_xml_xpath_context(void)
+{
+  cXMLXPathContext = rb_define_class_under(mXPath, "Context", rb_cObject);
+  rb_define_alloc_func(cXMLXPathContext, rxml_xpath_context_alloc);
+  rb_define_attr(cXMLXPathContext, "doc", 1, 0);
+  rb_define_method(cXMLXPathContext, "initialize", rxml_xpath_context_initialize, 1);
+  rb_define_method(cXMLXPathContext, "register_namespaces", rxml_xpath_context_register_namespaces, 1);
+  rb_define_method(cXMLXPathContext, "register_namespaces_from_node", rxml_xpath_context_register_namespaces_from_node, 1);
+  rb_define_method(cXMLXPathContext, "register_namespace", rxml_xpath_context_register_namespace, 2);
+  rb_define_method(cXMLXPathContext, "node=", rxml_xpath_context_node_set, 1);
+  rb_define_method(cXMLXPathContext, "find", rxml_xpath_context_find, 1);
+  rb_define_method(cXMLXPathContext, "enable_cache", rxml_xpath_context_enable_cache, -1);
+  rb_define_method(cXMLXPathContext, "disable_cache", rxml_xpath_context_disable_cache, 0);
+}