libxml-ruby 0.6.0-x86-mswin32-60

data/ext/libxml/ruby_xml_sax_parser.h

@@ -0,0 +1,56 @@
+/* $Id: ruby_xml_sax_parser.h 111 2006-11-20 01:39:14Z roscopeco $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_SAX_PARSER__
+#define __RUBY_XML_SAX_PARSER__
+
+extern VALUE cXMLSaxParser;
+extern VALUE mXMLSaxParserCallbacks;
+
+/*
+typedef struct ruby_xml_sax_parser_callbacks {
+    VALUE internalSubset;
+    VALUE isStandalone;
+    VALUE hasInternalSubset;
+    VALUE hasExternalSubset;
+    VALUE resolveEntity;
+    VALUE getEntity;
+    VALUE entityDecl;
+    VALUE notationDecl;
+    VALUE attributeDecl;
+    VALUE elementDecl;
+    VALUE unparsedEntityDecl;
+    VALUE setDocumentLocator;
+    VALUE startDocument;
+    VALUE endDocument;
+    VALUE startElement;
+    VALUE endElement;
+    VALUE reference;
+    VALUE characters;
+    VALUE ignorableWhitespace;
+    VALUE processingInstruction;
+    VALUE comment;
+    VALUE xmlParserWarning;
+    VALUE xmlParserError;
+    VALUE xmlParserFatalError;
+    VALUE getParameterEntity;
+    VALUE cdataBlock;
+    VALUE externalSubset;  
+} ruby_xml_sax_parser_callbacks;
+*/
+
+typedef struct ruby_xml_sax_parser {
+  xmlParserCtxtPtr xpc;
+  xmlSAXHandlerPtr xsh;
+  //ruby_xml_sax_parser_callbacks *cbp;
+  VALUE callbackHandler;
+  VALUE filename;
+  VALUE str;
+} ruby_xml_sax_parser;
+
+void ruby_xml_sax_parser_free(ruby_xml_sax_parser *rxsp);
+void ruby_init_xml_sax_parser(void);
+VALUE ruby_xml_sax_parser_new(VALUE class);
+
+#endif

data/ext/libxml/ruby_xml_schema.c

@@ -0,0 +1,146 @@
+#include "ruby_libxml.h"
+#include "ruby_xml_schema.h"
+
+VALUE cXMLSchema;
+
+static void
+ruby_xml_schema_mark(ruby_xml_schema *rxschema) {
+  return;
+}
+
+void
+ruby_xml_schema_free(ruby_xml_schema *rxschema) {
+  if (rxschema->schema != NULL) {
+    xmlSchemaFree(rxschema->schema);
+    rxschema->schema = NULL;
+  }
+
+  ruby_xfree(rxschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.new(schema_uri) => schema
+ * 
+ * Create a new schema from the specified URI.
+ */
+VALUE
+ruby_xml_schema_init_from_uri(int argc, VALUE *argv, VALUE class) {
+  xmlSchemaParserCtxtPtr parser;
+  ruby_xml_schema *schema;
+  
+  VALUE uri;
+  VALUE result = Qnil;
+
+  switch (argc) {
+  case 1:
+    rb_scan_args(argc, argv, "10", &uri);
+    Check_Type(uri, T_STRING);
+
+    parser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
+    schema = ALLOC(ruby_xml_schema);
+    schema->schema = xmlSchemaParse(parser);
+    xmlSchemaFreeParserCtxt(parser);
+ 	
+    result = Data_Wrap_Struct(cXMLSchema, ruby_xml_schema_mark, ruby_xml_schema_free, schema);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1)");
+  }
+  return(result);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.from_string("schema_data") => "value"
+ * 
+ * Create a new schema using the specified string.
+ */
+VALUE
+ruby_xml_schema_init_from_str(int argc, VALUE *argv, VALUE class) {
+  VALUE schema_str;
+
+  xmlSchemaParserCtxtPtr  parser;
+  //xmlSchemaPtr            sptr;
+  ruby_xml_schema *rxschema;
+
+  switch (argc) {
+  case 1:
+    rb_scan_args(argc, argv, "10", &schema_str);
+
+    Check_Type(schema_str, T_STRING);
+
+    parser = xmlSchemaNewMemParserCtxt(StringValuePtr(schema_str), strlen(StringValuePtr(schema_str)));
+    rxschema = ALLOC(ruby_xml_schema);
+    rxschema->schema = xmlSchemaParse(parser);
+ 	xmlSchemaFreeParserCtxt(parser);
+
+    return( Data_Wrap_Struct(cXMLSchema, ruby_xml_schema_mark, ruby_xml_schema_free, rxschema) );
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1)");
+  }
+  return Qnil;
+}
+  
+/* TODO what is this patch doing here?
+ 
+ 	xmlSchemaParserCtxtPtr  parser;
+ 	xmlSchemaPtr            sptr;
+ 	xmlSchemaValidCtxtPtr   vptr;
++	int                     is_invalid;
+ 	
+ 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &source) == FAILURE) {
+ 		return;
+@@ -598,26 +598,24 @@
+ 			convert_to_string_ex(&source);
+ 			parser = xmlSchemaNewParserCtxt(Z_STRVAL_P(source));
+ 			sptr = xmlSchemaParse(parser);
+ 			break;
+ 		case SCHEMA_BLOB:
+ 			convert_to_string_ex(&source);
+ 			parser = xmlSchemaNewMemParserCtxt(Z_STRVAL_P(source), Z_STRLEN_P(source));
+ 			sptr = xmlSchemaParse(parser);
+ 			break;
+ 	}
+ 
+ 	vptr = xmlSchemaNewValidCtxt(sptr);
++	is_invalid = xmlSchemaValidateDoc(vptr, (xmlDocPtr) sxe->document->ptr);
+ 	xmlSchemaFree(sptr);
+ 	xmlSchemaFreeValidCtxt(vptr);
+ 	xmlSchemaFreeParserCtxt(parser);
+ 
+-	if (is_valid) {
+-		RETURN_TRUE;
+-	} else {
++	if (is_invalid) {
+ 		RETURN_FALSE;
++	} else {
++		RETURN_TRUE;
+ 	}
+ }
+  }}} 
+@@ -695,7 +693,7 @@
+ {
+ 	if (!strcmp(method, "xsearch")) {
+ 		simplexml_ce_xpath_search(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+-#ifdef xmlSchemaParserCtxtPtr
++#ifdef LIBXML_SCHEMAS_ENABLED
+ 	} else if (!strcmp(method, "validate_schema_file")) {
+ 		simplexml_ce_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, SCHEMA_FILE);	
+ 	} else if (!strcmp(method, "validate_schema_buffer")) {
+*/
+
+void  ruby_schema_free(ruby_xml_schema *rxs) {
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void  ruby_init_xml_schema(void) {
+  cXMLSchema = rb_define_class_under(mXML, "Schema", rb_cObject);
+  rb_define_singleton_method(cXMLSchema, "new",         ruby_xml_schema_init_from_uri, -1);
+  rb_define_singleton_method(cXMLSchema, "from_string", ruby_xml_schema_init_from_str, -1);
+}
+

data/ext/libxml/ruby_xml_schema.h

@@ -0,0 +1,16 @@
+#ifndef __RUBY_XML_SCHEMA__
+#define __RUBY_XML_SCHEMA__
+
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemas.h>
+
+extern VALUE cXMLSchema;
+
+typedef struct rxp_schema {
+  xmlSchemaPtr schema;   /* Schema interface */
+} ruby_xml_schema;
+
+void  ruby_init_xml_schema(void);
+void  ruby_schema_free(ruby_xml_schema *rxs);
+#endif
+

data/ext/libxml/ruby_xml_state.c

@@ -0,0 +1,113 @@
+/* $Id$ */
+
+#include "ruby_libxml.h"
+
+VALUE cXMLState;
+static VALUE weak_holder;
+static int id_inst;
+
+ID id_state;
+
+#undef DEBUG
+
+void
+ruby_xml_state_free(int * dummy) {
+  if ( dummy==NULL ) return;
+  xmlCleanupParser();
+  ruby_xfree(dummy);
+  dummy=NULL;
+  weak_holder=Qnil;
+  rb_ivar_set(cXMLState,id_state,Qnil);
+}
+
+void
+ruby_xml_state_mark(void * a) {
+#ifdef DEBUG
+  fprintf(stderr,"marked 0x%x\n",NUM2INT(rb_ivar_get(cXMLState,id_state)));
+#endif
+}
+
+VALUE
+ruby_xml_state_object() {
+  VALUE obj,id;
+  int *dummy;
+
+  id=rb_ivar_get(cXMLState,id_state);
+  if (NIL_P(id)) {
+    obj = Data_Make_Struct(cXMLState, int,
+			   ruby_xml_state_mark,
+			   ruby_xml_state_free,
+			   dummy);
+    rb_ivar_set(cXMLState,id_state,id=rb_obj_id(obj));
+    *dummy=0;
+    weak_holder=obj;
+    return obj;
+  }
+
+#ifdef DEBUG
+  fprintf(stderr,"getting 0x%x\n",NUM2INT(id));
+#endif
+  return weak_holder;
+
+  return rb_funcall(rb_const_get(rb_cModule,rb_intern("ObjectSpace")),
+		    rb_intern("_id2ref"),
+		    1,
+		    id);
+}
+
+VALUE
+ruby_xml_state_object_find_aux(VALUE id) {
+  return rb_funcall(rb_const_get(rb_cModule,rb_intern("ObjectSpace")),
+	            rb_intern("_id2ref"),
+	            1, id);
+}
+
+
+static VALUE
+find_failed() {
+  return Qnil;
+}
+
+VALUE
+ruby_xml_state_object_find(VALUE id) {
+  return rb_rescue(ruby_xml_state_object_find_aux, id, find_failed, 0);
+}
+/*
+ * This will establish a use and mark it or mark an existing use.
+ * should be called by parser.mark and document.mark
+ */
+void
+ruby_xml_state_marker(void) {
+  ruby_xml_state_object();
+  rb_gc_mark(weak_holder);
+}
+
+VALUE
+ruby_xml_state_used_p(VALUE klass)
+{
+  return rb_ivar_get(cXMLState,id_state);
+}
+
+VALUE
+ruby_xml_state_use(VALUE klass)
+{
+  return ruby_xml_state_object();
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+
+void
+ruby_init_state(void) {	
+  cXMLState = rb_define_class_under(mXML, "State", rb_cObject);
+
+  rb_define_singleton_method(cXMLState, "used?",
+			     ruby_xml_state_used_p, 0);
+  rb_define_singleton_method(cXMLState, "use",
+			     ruby_xml_state_use, 0);
+
+  rb_ivar_set(cXMLState, id_state=rb_intern("@stateid"), Qnil);
+}

data/ext/libxml/ruby_xml_state.h

@@ -0,0 +1,12 @@
+/* $Id$ */
+
+#ifndef __RUBY_XML_STATE__
+#define __RUBY_XML_STATE__
+
+extern VALUE cXMLState;
+
+void ruby_init_state(void);
+void ruby_xml_state_marker(void);
+VALUE ruby_xml_state_object_find(VALUE id);
+
+#endif

data/ext/libxml/ruby_xml_tree.c

@@ -0,0 +1,43 @@
+/* $Id: ruby_xml_tree.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_tree.h"
+
+VALUE cXMLTree;
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_tree(void) {
+  cXMLTree = rb_define_class_under(mXML, "Tree", rb_cObject);
+
+  rb_define_const(cXMLTree, "ELEMENT_NODE", INT2FIX(XML_ELEMENT_NODE));
+  rb_define_const(cXMLTree, "ATTRIBUTE_NODE", INT2FIX(XML_ATTRIBUTE_NODE));
+  rb_define_const(cXMLTree, "TEXT_NODE", INT2FIX(XML_TEXT_NODE));
+  rb_define_const(cXMLTree, "CDATA_SECTION_NODE", INT2FIX(XML_CDATA_SECTION_NODE));
+  rb_define_const(cXMLTree, "ENTITY_REF_NODE", INT2FIX(XML_ENTITY_REF_NODE));
+  rb_define_const(cXMLTree, "ENTITY_NODE", INT2FIX(XML_ENTITY_NODE));
+  rb_define_const(cXMLTree, "PI_NODE", INT2FIX(XML_PI_NODE));
+  rb_define_const(cXMLTree, "COMMENT_NODE", INT2FIX(XML_COMMENT_NODE));
+  rb_define_const(cXMLTree, "DOCUMENT_NODE", INT2FIX(XML_DOCUMENT_NODE));
+  rb_define_const(cXMLTree, "DOCUMENT_TYPE_NODE", INT2FIX(XML_DOCUMENT_TYPE_NODE));
+  rb_define_const(cXMLTree, "DOCUMENT_FRAG_NODE", INT2FIX(XML_DOCUMENT_FRAG_NODE));
+  rb_define_const(cXMLTree, "NOTATION_NODE", INT2FIX(XML_NOTATION_NODE));
+  rb_define_const(cXMLTree, "HTML_DOCUMENT_NODE", INT2FIX(XML_HTML_DOCUMENT_NODE));
+  rb_define_const(cXMLTree, "DTD_NODE", INT2FIX(XML_DTD_NODE));
+  rb_define_const(cXMLTree, "ELEMENT_DECL", INT2FIX(XML_ELEMENT_DECL));
+  rb_define_const(cXMLTree, "ATTRIBUTE_DECL", INT2FIX(XML_ATTRIBUTE_DECL));
+  rb_define_const(cXMLTree, "ENTITY_DECL", INT2FIX(XML_ENTITY_DECL));
+  rb_define_const(cXMLTree, "NAMESPACE_DECL", INT2FIX(XML_NAMESPACE_DECL));
+  rb_define_const(cXMLTree, "XINCLUDE_START", INT2FIX(XML_XINCLUDE_START));
+  rb_define_const(cXMLTree, "XINCLUDE_END", INT2FIX(XML_XINCLUDE_END));
+
+#ifdef LIBXML_DOCB_ENABLED
+  rb_define_const(cXMLTree, "DOCB_DOCUMENT_NODE", INT2FIX(XML_DOCB_DOCUMENT_NODE));
+#endif
+}

data/ext/libxml/ruby_xml_tree.h

@@ -0,0 +1,12 @@
+/* $Id: ruby_xml_tree.h 39 2006-02-21 20:40:16Z roscopeco $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_TREE__
+#define __RUBY_XML_TREE__
+
+extern VALUE cXMLTree;
+
+void ruby_init_xml_tree(void);
+
+#endif

data/ext/libxml/ruby_xml_xinclude.c

@@ -0,0 +1,20 @@
+/* $Id: ruby_xml_xinclude.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xinclude.h"
+
+VALUE cXMLXInclude;
+VALUE eXMLXIncludeError;
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_xinclude(void) {
+  cXMLXInclude = rb_define_class_under(mXML, "XInclude", rb_cObject);
+  eXMLXIncludeError = rb_define_class_under(cXMLXInclude, "Error", rb_eRuntimeError);
+}

data/ext/libxml/ruby_xml_xinclude.h

@@ -0,0 +1,13 @@
+/* $Id: ruby_xml_xinclude.h 39 2006-02-21 20:40:16Z roscopeco $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XINCLUDE__
+#define __RUBY_XML_XINCLUDE__
+
+extern VALUE cXMLXInclude;
+extern VALUE eXMLXIncludeError;
+
+void ruby_init_xml_xinclude(void);
+
+#endif

data/ext/libxml/ruby_xml_xpath.c

@@ -0,0 +1,243 @@
+/* $Id: ruby_xml_xpath.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xpath.h"
+
+/*
+ * Document-class: XML::XPath
+ * 
+ * Includes Enumerable.
+ */
+VALUE cXMLXPath;
+VALUE eXMLXPathInvalidPath;
+
+#ifdef LIBXML_XPATH_ENABLED
+
+/*
+ * call-seq:
+ *    xpath.debug => (true|false)
+ * 
+ * Dump libxml debugging information to stdout.
+ * Requires Libxml be compiled with debugging enabled.
+ */
+VALUE
+ruby_xml_xpath_debug(VALUE self) {
+#ifdef LIBXML_DEBUG_ENABLED
+  ruby_xml_xpath *rxxp;
+  Data_Get_Struct(self, ruby_xml_xpath, rxxp);
+
+  if (rxxp->xpop != NULL) {
+    xmlXPathDebugDumpObject(stdout, rxxp->xpop, 0);
+    return(Qtrue);
+  } else {
+    return(Qfalse);
+  }
+#else
+  rb_warn("libxml does not have debugging turned on");
+  return(Qfalse);
+#endif
+}
+
+///////////////////////////////////////////////////
+// TODO xpath_find is throwing TypeError:
+//
+//    TypeError: can't convert nil into String
+//
+// When given a namespace when non exist.
+void
+ruby_xml_xpath_register_namespaces(VALUE nslist, VALUE xxpc, int level) {
+  char *cp;
+  long i;
+  VALUE rprefix, ruri;
+  ruby_xml_ns *rxns;
+
+  /* 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 */
+    ruby_xml_xpath_context_register_namespace(xxpc, rprefix, ruri);
+    break;
+  case T_ARRAY:
+    if ( level == 0 ) {
+      for (i = 0; i < RARRAY(nslist)->len; i++) {
+	ruby_xml_xpath_register_namespaces(RARRAY(nslist)->ptr[i],xxpc,1);
+      }
+    }
+    else {
+      // tuples of prefix/uri
+      if (RARRAY(nslist)->len == 2) {
+	rprefix = RARRAY(nslist)->ptr[0];
+	ruri = RARRAY(nslist)->ptr[1];
+	ruby_xml_xpath_context_register_namespace(xxpc, rprefix, ruri);
+      } else {
+	rb_raise(rb_eArgError, "nested array must be an array of strings, prefix and href/uri");
+      }
+    }
+    break;
+  default:
+    if (rb_obj_is_kind_of(nslist, cXMLNS) == Qtrue) {
+      Data_Get_Struct(nslist, ruby_xml_ns, rxns);
+      rprefix = rb_str_new2((const char*)rxns->ns->prefix);
+      ruri = rb_str_new2((const char*)rxns->ns->href);
+      ruby_xml_xpath_context_register_namespace(xxpc, rprefix, ruri);
+    } else
+      rb_raise(rb_eArgError, "Invalid argument type, only accept string, array of strings, or an array of arrays");
+  }
+}
+/*
+ * call-seq:
+ *    XML::XPath.find(path, namespaces = [any]) => xpath
+ * 
+ * Find nodes matching the specified xpath (and optionally any of the
+ * supplied namespaces) and return as an XML::Node::Set.
+ * 
+ * The optional namespaces argument may take one of
+ * two forms:
+ * 
+ * * A string in the form of: "prefix:uri", or
+ * * An array of:
+ *   * strings in the form like above
+ *   * arrays in the form of ['prefix','uri']
+ * 
+ * If not specified, matching nodes from any namespace
+ * will be included.
+ */
+VALUE
+ruby_xml_xpath_find(VALUE class, VALUE anode, VALUE xpath_expr, VALUE nslist) {
+#ifdef LIBXML_XPATH_ENABLED
+  xmlXPathCompExprPtr comp;
+  xmlXPathObjectPtr xxpop;
+  ruby_xml_node *node;
+  xmlXPathContextPtr ctxt;
+  ruby_xml_document_t *rdocp;
+  VALUE rnode, xxpc;
+  VALUE rxpop;
+
+  if (rb_obj_is_kind_of(anode, cXMLDocument) == Qtrue) {
+    xxpc = ruby_xml_xpath_context_new(anode);
+    Data_Get_Struct(anode, ruby_xml_document_t, rdocp);
+#ifdef DEBUG
+    fprintf(stderr,"rdocp=0x%x root=0x%x\n",rdocp,xmlDocGetRootElement(rdocp->doc));
+#endif
+    rnode=ruby_xml_node2_wrap(cXMLNode,xmlDocGetRootElement(rdocp->doc));
+#ifdef DEBUG
+    fprintf(stderr,"rnode 0x%x 0x%x\n",rnode,xmlDocGetRootElement(rdocp->doc)->_private);
+#endif
+    Data_Get_Struct(rnode, ruby_xml_node, node);
+  } else if ( rb_obj_is_kind_of(anode, cXMLNode) == Qtrue) {
+    xxpc = ruby_xml_xpath_context_new(anode);
+    Data_Get_Struct(anode, ruby_xml_node, node);
+  } else
+    rb_raise(rb_eTypeError, "arg 1 must be XML::Document or XML::Node within a document %s", rb_obj_as_string(anode));
+  
+  if (NIL_P(xxpc))
+    return(Qnil);
+
+  Data_Get_Struct(xxpc,xmlXPathContext,ctxt);
+  // XXX Is this legal? Set a subtree to apply xpath?
+  ctxt->node = node->node;
+
+  // XXX is setting ->namespaces used?
+  if (node->node->type == XML_DOCUMENT_NODE) {
+    ctxt->namespaces = xmlGetNsList(node->node->doc,
+				    xmlDocGetRootElement(node->node->doc));
+  } else {
+    ctxt->namespaces = xmlGetNsList(node->node->doc, node->node);
+  }
+
+  ctxt->nsNr = 0;
+  if (ctxt->namespaces != NULL) {
+    while (ctxt->namespaces[ctxt->nsNr] != NULL)
+      ctxt->nsNr++;
+  }
+
+  if ( ! NIL_P(nslist) )
+    ruby_xml_xpath_register_namespaces(nslist,xxpc,0);
+
+  comp = xmlXPathCompile((xmlChar*)StringValuePtr(xpath_expr));
+
+  if (comp == NULL) {
+    rb_raise(eXMLXPathInvalidPath,
+	     "Invalid XPath expression (expr does not compile)");
+  }
+  xxpop=xmlXPathCompiledEval(comp, ctxt);
+  if ( xxpop == NULL )
+    return Qnil;
+
+  rxpop = ruby_xml_xpath_object_wrap(xxpop);
+
+#ifdef NODE_DEBUG
+  fprintf(stderr,"xpo 0x%x class=%s\n",
+	  rxpop,
+	  rb_class2name(rb_obj_class(rxpop)));
+#endif
+
+  xmlXPathFreeCompExpr(comp);
+
+  if (rxpop == Qnil)
+    rb_raise(eXMLXPathInvalidPath,
+	     "Invalid XPath expression for this document");
+
+  return rxpop;
+#else
+  rb_warn("libxml was compiled without XPath support");
+  return(Qfalse);
+#endif
+}
+
+
+VALUE
+ruby_xml_xpath_findva(int argc, VALUE *argv, VALUE class) {
+  if ( argc < 2 || argc > 3 )
+    rb_raise(rb_eArgError, "wrong number of arguments (1 or 2)");
+
+  return ruby_xml_xpath_find(class,argv[0],argv[1],(argc==3)?argv[2]:Qnil);
+}
+
+VALUE
+ruby_xml_xpath_find2(VALUE anode, VALUE xpath_expr, VALUE nslist) {
+  return ruby_xml_xpath_find(cXMLXPath, anode, xpath_expr, nslist);
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_xpath(void) {
+  cXMLXPath = rb_define_class_under(mXML, "XPath", rb_cObject);
+  rb_include_module(cXMLNode, rb_const_get(rb_cObject, rb_intern("Enumerable")));
+
+  eXMLXPathInvalidPath = rb_define_class_under(cXMLXPath, "InvalidPath", eXMLError);
+
+  rb_define_const(cXMLXPath, "UNDEFINED", INT2NUM(XPATH_UNDEFINED));
+  rb_define_const(cXMLXPath, "NODESET", INT2NUM(XPATH_NODESET));
+  rb_define_const(cXMLXPath, "BOOLEAN", INT2NUM(XPATH_BOOLEAN));
+  rb_define_const(cXMLXPath, "NUMBER", INT2NUM(XPATH_NUMBER));
+  rb_define_const(cXMLXPath, "STRING", INT2NUM(XPATH_STRING));
+  rb_define_const(cXMLXPath, "POINT", INT2NUM(XPATH_POINT));
+  rb_define_const(cXMLXPath, "RANGE", INT2NUM(XPATH_RANGE));
+  rb_define_const(cXMLXPath, "LOCATIONSET", INT2NUM(XPATH_LOCATIONSET));
+  rb_define_const(cXMLXPath, "USERS", INT2NUM(XPATH_USERS));
+  rb_define_const(cXMLXPath, "XSLT_TREE", INT2NUM(XPATH_XSLT_TREE));
+
+  rb_define_singleton_method(cXMLXPath, "find", ruby_xml_xpath_findva, -1);
+
+  rb_define_method(cXMLXPath, "debug", ruby_xml_xpath_debug, 0);
+
+  ruby_init_xml_xpath_object();
+}
+
+#endif /* ifdef LIBXML_XPATH_ENABLED */