mkrf 0.1.0

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/ruby_xml_xpath.h

@@ -0,0 +1,24 @@
+/* $Id: ruby_xml_xpath.h,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPATH__
+#define __RUBY_XML_XPATH__
+
+extern VALUE cXMLXPath;
+extern VALUE eXMLXPathInvalidPath;
+
+typedef struct ruby_xml_xpath {
+  VALUE xd;
+  VALUE ctxt;
+  xmlXPathObjectPtr xpop;
+} ruby_xml_xpath;
+
+void ruby_xml_xpath_free(ruby_xml_xpath *rxxp);
+VALUE ruby_xml_xpath_find(int argc, VALUE *argv, VALUE class);
+VALUE ruby_xml_xpath_find2(int argc, VALUE *argv);
+VALUE ruby_xml_xpath_new(VALUE class, VALUE xd, VALUE xxpc,
+			 xmlXPathObjectPtr xpop);
+void ruby_init_xml_xpath(void);
+
+#endif

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/ruby_xml_xpath_context.c

@@ -0,0 +1,125 @@
+/* $Id: ruby_xml_xpath_context.c,v 1.2 2006/02/27 12:55:32 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "libxml.h"
+#include "ruby_xml_xpath_context.h"
+
+VALUE cXMLXPathContext;
+
+/*
+ * call-seq:
+ *    context.doc => document
+ * 
+ * Obtain the XML::Document associated with this XPath.
+ */
+VALUE
+ruby_xml_xpath_context_doc_get(VALUE self) {
+  ruby_xml_xpath_context *rxxpc;
+  Data_Get_Struct(self, ruby_xml_xpath_context, rxxpc);
+
+  return(rxxpc->xd);
+}
+
+
+void
+ruby_xml_xpath_context_free(ruby_xml_xpath_context *rxxpc) {
+  if (rxxpc->ctxt != NULL) {
+    xmlXPathFreeContext(rxxpc->ctxt);
+    rxxpc->ctxt = NULL;
+  }
+
+  free(rxxpc);
+}
+
+
+void
+ruby_xml_xpath_context_mark(ruby_xml_xpath_context *rxxpc) {
+  if (rxxpc == NULL) return;
+  if (!NIL_P(rxxpc->xd)) rb_gc_mark(rxxpc->xd);
+}
+
+
+VALUE
+ruby_xml_xpath_context_new(VALUE class, VALUE xd,
+				 xmlXPathContextPtr xxpc) {
+  ruby_xml_xpath_context *rxxpc;
+
+  rxxpc = ALLOC(ruby_xml_xpath_context);
+  rxxpc->ctxt = xxpc;
+  rxxpc->xd = xd;
+  return(Data_Wrap_Struct(class, ruby_xml_xpath_context_mark,
+			  ruby_xml_xpath_context_free, rxxpc));
+}
+
+
+VALUE
+ruby_xml_xpath_context_new2(VALUE xd, xmlXPathContextPtr xxpc) {
+  return(ruby_xml_xpath_context_new(cXMLXPathContext, xd, xxpc));
+}
+
+
+VALUE
+ruby_xml_xpath_context_new3(VALUE xd) {
+  ruby_xml_document *rxd;
+  xmlXPathContextPtr ctxt;
+
+  Data_Get_Struct(xd, ruby_xml_document, rxd);
+  if (rxd->doc == NULL)
+    return(Qnil);
+
+  ctxt = xmlXPathNewContext(rxd->doc);
+  if (ctxt == NULL)
+    return(Qnil);
+
+  return(ruby_xml_xpath_context_new2(xd, ctxt));
+}
+
+
+VALUE
+ruby_xml_xpath_context_new4(VALUE rnode) {
+  ruby_xml_node *node;
+
+  Data_Get_Struct(rnode, ruby_xml_node, node);
+  return(ruby_xml_xpath_context_new3(node->xd));
+}
+
+
+/*
+ * call-seq:
+ *    context.register_namespace(prefix, uri) => (true|false)
+ * 
+ * Register the specified namespace URI with the specified prefix
+ * in this context.
+ */
+VALUE
+ruby_xml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri) {
+  ruby_xml_xpath_context *rxxpc;
+
+  Data_Get_Struct(self, ruby_xml_xpath_context, rxxpc);
+  if (xmlXPathRegisterNs(rxxpc->ctxt, 
+                         (xmlChar*)StringValuePtr(prefix), 
+                         (xmlChar*)StringValuePtr(uri)) 
+                         == 0) {
+    return(Qtrue);
+  } else {
+    /* Should raise an exception, IMHO */
+    return(Qfalse);
+  }
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+  cXMLXPath = rb_define_class_under(mXML, "XPath", rb_cObject);
+#endif
+
+void
+ruby_init_xml_xpath_context(void) {
+  cXMLXPathContext = rb_define_class_under(cXMLXPath, "Context", rb_cObject);
+
+  rb_define_method(cXMLXPathContext, "register_namespace",
+		   ruby_xml_xpath_context_register_namespace, 2);
+  rb_define_method(cXMLXPathContext, "doc",
+		   ruby_xml_xpath_context_doc_get, 0);
+}

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/ruby_xml_xpath_context.h

@@ -0,0 +1,24 @@
+/* $Id: ruby_xml_xpath_context.h,v 1.2 2006/02/27 12:55:32 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPATH_CONTEXT__
+#define __RUBY_XML_XPATH_CONTEXT__
+
+extern VALUE cXMLXPathContext;
+
+typedef struct ruby_xml_xpath_context {
+  VALUE xd;
+  xmlXPathContextPtr ctxt;
+} ruby_xml_xpath_context;
+
+void ruby_xml_xpath_context_free(ruby_xml_xpath_context *rxxpc);
+VALUE ruby_xml_xpath_context_new(VALUE class, VALUE xd,
+				 xmlXPathContextPtr ctxt);
+VALUE ruby_xml_xpath_context_new2(VALUE xd, xmlXPathContextPtr ctxt);
+VALUE ruby_xml_xpath_context_new3(VALUE xd);
+VALUE ruby_xml_xpath_context_new4(VALUE rnode);
+VALUE ruby_xml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri);
+void ruby_init_xml_xpath_context(void);
+
+#endif

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/ruby_xml_xpointer.c

@@ -0,0 +1,100 @@
+/* $Id: ruby_xml_xpointer.c,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "libxml.h"
+#include "ruby_xml_xpointer.h"
+
+VALUE cXMLXPointer;
+VALUE eXMLXPointerInvalidExpression;
+
+VALUE
+ruby_xml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
+#ifdef LIBXML_XPTR_ENABLED
+  ruby_xml_node *node;
+  ruby_xml_xpath_context *xxpc;
+  VALUE rxptr_xpth_ctxt, rxxp;
+  xmlXPathObjectPtr xpath;
+
+  Check_Type(xptr_str, T_STRING);
+  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "require an XML::Node object");
+
+  Data_Get_Struct(rnode, ruby_xml_node, node);
+
+  rxptr_xpth_ctxt = ruby_xml_xpath_context_new(cXMLXPathContext, node->xd,
+					       xmlXPtrNewContext(node->node->doc, node->node, NULL));
+  if (NIL_P(rxptr_xpth_ctxt))
+    return(Qnil);
+  Data_Get_Struct(rxptr_xpth_ctxt, ruby_xml_xpath_context, xxpc);
+
+  xpath = xmlXPtrEval((xmlChar*)StringValuePtr(xptr_str), xxpc->ctxt);
+  if (xpath == NULL)
+    rb_raise(eXMLXPointerInvalidExpression, "invalid xpointer expression");
+
+  rxxp = ruby_xml_xpath_new(cXMLXPath, node->xd, rxptr_xpth_ctxt, xpath);
+  return(rxxp);
+#else
+  rb_warn("libxml was compiled without XPointer support");
+  return(Qfalse);
+#endif
+}
+
+
+VALUE
+ruby_xml_xpointer_point2(VALUE node, VALUE xptr_str) {
+  return(ruby_xml_xpointer_point(cXMLXPointer, node, xptr_str));
+}
+
+
+/*
+ * call-seq:
+ *    XML::XPointer.range(start_node, end_node) => xpath
+ * 
+ * Create an xpath representing the range between the supplied
+ * start and end node.
+ */
+VALUE
+ruby_xml_xpointer_range(VALUE class, VALUE rstart, VALUE rend) {
+#ifdef LIBXML_XPTR_ENABLED
+  ruby_xml_node *start, *end;
+  VALUE rxxp;
+  xmlXPathObjectPtr xpath;
+
+  if (rb_obj_is_kind_of(rstart, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "require an XML::Node object as a starting point");
+  if (rb_obj_is_kind_of(rend, cXMLNode) == Qfalse)
+    rb_raise(rb_eTypeError, "require an XML::Node object as an ending point");
+
+  Data_Get_Struct(rstart, ruby_xml_node, start);
+  if (start->node == NULL)
+    return(Qnil);
+
+  Data_Get_Struct(rend, ruby_xml_node, end);
+  if (end->node == NULL)
+    return(Qnil);
+
+  xpath = xmlXPtrNewRangeNodes(start->node, end->node);
+  if (xpath == NULL)
+    rb_fatal("You shouldn't be able to have this happen");
+
+  rxxp = ruby_xml_xpath_new(cXMLXPath, start->xd, Qnil, xpath);
+  return(rxxp);
+#else
+  rb_warn("libxml was compiled without XPointer support");
+  return(Qfalse);
+#endif
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_xpointer(void) {
+  cXMLXPointer = rb_define_class_under(mXML, "XPointer", rb_cObject);
+  eXMLXPointerInvalidExpression = rb_define_class_under(cXMLXPointer, "InvalidExpression", rb_eException);
+
+  rb_define_singleton_method(cXMLXPointer, "range", ruby_xml_xpointer_range, 2);
+}

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/ruby_xml_xpointer.h

@@ -0,0 +1,27 @@
+/* $Id: ruby_xml_xpointer.h,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPOINTER__
+#define __RUBY_XML_XPOINTER__
+
+extern VALUE cXMLXPointer;
+extern VALUE eXMLXPointerInvalidExpression;
+
+typedef struct ruby_xml_xpointer {
+  VALUE xd;
+  VALUE ctxt;
+  /*
+   * This needs to go into a xpointer data struct:
+   *
+   * xmlLocationSetPtr xptr;
+   *
+   * I also need an xpointer data struct type.
+  */
+} ruby_xml_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

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/ruby_xml_xpointer_context.c

@@ -0,0 +1,21 @@
+/* $Id: ruby_xml_xpointer_context.c,v 1.2 2006/02/27 12:55:32 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "libxml.h"
+#include "ruby_xml_xpointer_context.h"
+
+VALUE cXMLXPointerContext;
+VALUE eXMLXPointerContextInvalidPath;
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+  cXMLXPointer = rb_define_class_under(mXML, "XPointer", rb_cObject);
+#endif
+
+void
+ruby_init_xml_xpointer_context(void) {
+  cXMLXPointerContext = rb_define_class_under(cXMLXPointer, "Context", cXMLXPathContext);
+  eXMLXPointerContextInvalidPath = rb_define_class_under(cXMLXPointerContext, "InvalidPath", rb_eException);
+}

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/ruby_xml_xpointer_context.h

@@ -0,0 +1,18 @@
+/* $Id: ruby_xml_xpointer_context.h,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPOINTER_CONTEXT__
+#define __RUBY_XML_XPOINTER_CONTEXT__
+
+extern VALUE cXMLXPointerContext;
+extern VALUE eXMLXPointerContextInvalidPath;
+
+typedef struct ruby_xml_xpointer_context {
+  VALUE xd;
+  xmlXPathContextPtr ctxt;
+} ruby_xml_xpointer_context;
+
+void ruby_init_xml_xpointer_context(void);
+
+#endif

data/test/sample_files/libxml-ruby-0.3.8/ext/xml/sax_parser_callbacks.inc

@@ -0,0 +1,202 @@
+/* $Id: sax_parser_callbacks.inc,v 1.1 2006/04/14 14:50:58 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+/*
+ * SAX CALLBACK HANDLERS
+ */ 
+static void internal_subset_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *name,
+       const char *extid,
+       const char *sysid) {
+  VALUE handler = cbp->internalSubset;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler, callsym, 3, rb_str_new2(name),
+        rb_str_new2(extid), rb_str_new2(sysid));
+  }    
+}
+
+static void is_standalone_func(ruby_xml_sax_parser_callbacks *cbp) {
+  VALUE handler = cbp->isStandalone;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,0);
+  }    
+}
+
+static void has_internal_subset_func(ruby_xml_sax_parser_callbacks *cbp) {
+  VALUE handler = cbp->hasInternalSubset;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,0);
+  }    
+}
+
+static void has_external_subset_func(ruby_xml_sax_parser_callbacks *cbp) {
+  VALUE handler = cbp->hasExternalSubset;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,0);
+  }    
+}
+
+static void start_document_func(ruby_xml_sax_parser_callbacks *cbp) {
+  VALUE handler = cbp->startDocument;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,0);
+  }    
+}
+
+static void end_document_func(ruby_xml_sax_parser_callbacks *cbp) {
+  VALUE handler = cbp->endDocument;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,0);
+  }    
+}
+
+static void start_element_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *name, const char **attrs) {  
+  VALUE handler = cbp->startElement;
+  VALUE ahsh = rb_hash_new();
+  const char *attr, *value;
+  
+  if (attrs) {
+    while ((attr = *(attrs++))) {
+      value = *(attrs++);            
+      rb_hash_aset(ahsh, rb_str_new2(attr), rb_str_new2(value));
+    }
+  }    
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,2,rb_str_new2(name),ahsh);
+  }    
+}        
+
+static void end_element_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *name) {
+  VALUE handler = cbp->endElement;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new2(name));
+  }    
+}
+
+static void reference_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *name) {
+  VALUE handler = cbp->reference;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new2(name));
+  }    
+}
+
+static void characters_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *chars, int len) {
+  VALUE handler = cbp->characters;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new(chars, len));
+  }    
+}
+
+static void processing_instruction_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *target, const char *data) {
+  VALUE handler = cbp->processingInstruction;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler, callsym, 2,
+        rb_str_new2(target),rb_str_new2(data));
+  }    
+}
+
+static void comment_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *msg) {
+  VALUE handler = cbp->comment;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new2(msg));
+  }    
+}
+
+// TODO these next three should actually be formatting messages.
+static void warning_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *msg, ...) {
+  VALUE handler = cbp->xmlParserWarning;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new2(msg));
+  }    
+}
+
+static void error_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *msg, ...) {
+  VALUE handler = cbp->xmlParserError;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new2(msg));
+  }    
+}
+
+static void fatal_error_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *msg, ...) {
+  VALUE handler = cbp->xmlParserFatalError;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new2(msg));
+  }    
+}
+
+static void cdata_block_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *value, int len) {
+  VALUE handler = cbp->cdataBlock;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler,callsym,1,rb_str_new(value, len));
+  }    
+}
+
+static void external_subset_func(ruby_xml_sax_parser_callbacks *cbp, 
+       const char *name,
+       const char *extid,
+       const char *sysid) {
+  VALUE handler = cbp->externalSubset;
+  
+  if (handler && handler != Qnil) {
+    rb_funcall(handler, callsym, 3, rb_str_new2(name),
+        rb_str_new2(extid), rb_str_new2(sysid));
+  }    
+}
+
+static xmlSAXHandler rubySAXHandlerStruct = {
+  (internalSubsetSAXFunc)internal_subset_func,
+  (isStandaloneSAXFunc)is_standalone_func,
+  (hasInternalSubsetSAXFunc)has_internal_subset_func,
+  (hasExternalSubsetSAXFunc)has_external_subset_func,
+  0, /* resolveEntity */
+  0, /* getEntity */
+  0, /* entityDecl */
+  0, /* notationDecl */
+  0, /* attributeDecl */
+  0, /* elementDecl */
+  0, /* unparsedEntityDecl */
+  0, /* setDocumentLocator */
+  (startDocumentSAXFunc)start_document_func, 
+  (endDocumentSAXFunc)end_document_func, 
+  (startElementSAXFunc)start_element_func, 
+  (endElementSAXFunc)end_element_func, 
+  (referenceSAXFunc)reference_func,
+  (charactersSAXFunc)characters_func,
+  0, /* ignorableWhitespace */
+  (processingInstructionSAXFunc)processing_instruction_func,
+  (commentSAXFunc)comment_func,
+  (warningSAXFunc)warning_func,
+  (errorSAXFunc)error_func,
+  (fatalErrorSAXFunc)fatal_error_func,
+  0, /* xmlGetParameterEntity */
+  (cdataBlockSAXFunc)cdata_block_func,
+  (externalSubsetSAXFunc)external_subset_func,
+  1
+};