mkrf 0.1.0

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

@@ -0,0 +1,22 @@
+/* $Id: ruby_xml_parser_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_PARSER_CONTEXT__
+#define __RUBY_XML_PARSER_CONTEXT__
+
+extern VALUE cXMLParserContext;
+
+typedef struct ruby_xml_parser_context {
+  xmlParserCtxtPtr ctxt;
+  int is_ptr;
+} ruby_xml_parser_context;
+
+void ruby_xml_parser_context_free(ruby_xml_parser_context *ctxt);
+void ruby_init_xml_parser_context(void);
+VALUE ruby_xml_parser_context_new(VALUE class, xmlParserCtxtPtr ctxt);
+VALUE ruby_xml_parser_context_new2(VALUE class);
+VALUE ruby_xml_parser_context_new3();
+VALUE ruby_xml_parser_context_each(VALUE self);
+
+#endif

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

@@ -0,0 +1,426 @@
+/* $Id: ruby_xml_sax_parser.c,v 1.4 2006/04/14 23:46:06 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "libxml.h"
+#include "ruby_xml_sax_parser.h"
+
+VALUE cXMLSaxParser;
+VALUE callsym;
+
+#include "sax_parser_callbacks.inc"
+
+void
+ruby_xml_sax_parser_free(ruby_xml_sax_parser *rxsp) {
+  /* Apparently this isn't needed: time will tell */
+  /* if (rxsp->xsh != NULL) */
+  /* xmlFreeSax_Parser(rxsp->sax_parser); */
+}
+
+#define mark_handler(rxsp, handler) \
+    if (rxsp->cbp->handler && (rxsp->cbp->handler != Qnil)) \
+      rb_gc_mark(rxsp->cbp->handler)
+  
+void
+ruby_xml_sax_parser_mark(ruby_xml_sax_parser *rxsp) {
+  mark_handler(rxsp, internalSubset);
+  mark_handler(rxsp, isStandalone);
+  mark_handler(rxsp, hasInternalSubset);
+  mark_handler(rxsp, hasExternalSubset);
+  mark_handler(rxsp, startDocument);
+  mark_handler(rxsp, endDocument);
+  mark_handler(rxsp, startElement);
+  mark_handler(rxsp, endElement);
+  mark_handler(rxsp, reference);
+  mark_handler(rxsp, characters);
+  mark_handler(rxsp, processingInstruction);
+  mark_handler(rxsp, comment);
+  mark_handler(rxsp, xmlParserWarning);
+  mark_handler(rxsp, xmlParserError);
+  mark_handler(rxsp, xmlParserFatalError);
+  mark_handler(rxsp, cdataBlock);
+}
+
+
+/*
+ * call-seq:
+ *    XML::SaxParser.new => sax_parser
+ * 
+ * Create a new XML::SaxParser instance.
+ */
+VALUE
+ruby_xml_sax_parser_new(VALUE class) {
+  ruby_xml_sax_parser *rxsp;
+  
+  rxsp = ALLOC(ruby_xml_sax_parser);
+  rxsp->cbp = ALLOC(ruby_xml_sax_parser_callbacks);
+  memset(rxsp->cbp, 0, sizeof(ruby_xml_sax_parser_callbacks));
+  rxsp->xsh = &rubySAXHandlerStruct;
+  
+  rxsp->xpc = NULL;
+  rxsp->filename = Qnil;
+  rxsp->str = Qnil;
+
+  return(Data_Wrap_Struct(class, ruby_xml_sax_parser_mark, 
+                              ruby_xml_sax_parser_free, rxsp));
+}
+
+
+/*
+ * call-seq:
+ *    sax_parser.filename => "filename"
+ * 
+ * Obtain the filename this parser reads from.
+ */
+VALUE
+ruby_xml_sax_parser_filename_get(VALUE self) {
+  ruby_xml_sax_parser *rxsp;
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  return(rxsp->filename);
+}
+
+
+/*
+ * call-seq:
+ *    sax_parser.filename = "filename"
+ * 
+ * Set the filename this parser reads from.
+ */
+VALUE
+ruby_xml_sax_parser_filename_set(VALUE self, VALUE filename) {
+  ruby_xml_sax_parser *rxsp;
+  Check_Type(filename, T_STRING);
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  rxsp->filename = filename;
+  return(rxsp->filename);
+}
+
+#define set_handler(self, argc, argv, handler)      \
+  VALUE proc;                                       \
+  rb_scan_args(argc, argv, "0&", &proc);            \
+  ruby_xml_sax_parser *rxsp;                        \
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp); \
+  rxsp->cbp->handler = proc;                        \
+  return(Qnil);
+
+
+/*
+ * call-seq:
+ *    parser.on_internal_subset { |name, external_id, system_id| ... } => nil
+ *
+ * Set the callback block for an internal subset event.
+ */
+VALUE
+ruby_xml_sax_parser_on_internal_subset(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, internalSubset);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_is_standalone { || ... } => nil
+ *
+ * Set the callback proc for 'is standalone' event.
+ */
+VALUE
+ruby_xml_sax_parser_on_is_standalone(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, isStandalone);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_has_internal_subset { || ... } => nil
+ *
+ * Set the callback proc for an internal subset notification event.
+ */
+VALUE
+ruby_xml_sax_parser_on_has_internal_subset(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, hasInternalSubset);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_has_external_subset { || ... } => nil
+ *
+ * Set the callback proc for an external subset notification event.
+ */
+VALUE
+ruby_xml_sax_parser_on_has_external_subset(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, hasExternalSubset);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_start_document { || ... } => nil
+ *
+ * Set the callback proc for a start document event.
+ */
+VALUE
+ruby_xml_sax_parser_on_start_document(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, startDocument);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_end_document { || ... } => nil
+ *
+ * Set the callback proc for an end document event.
+ */
+VALUE
+ruby_xml_sax_parser_on_end_document(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, endDocument);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_start_element { |name, attr_hash| ... } => nil
+ * 
+ * Set the callback proc for an element start event.
+ */
+VALUE
+ruby_xml_sax_parser_on_start_element(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, startElement);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_end_element { |name| ... } => nil
+ *
+ * Set the callback proc for an element end event.
+ */
+VALUE
+ruby_xml_sax_parser_on_end_element(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, endElement);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_reference { |name| ... } => nil
+ *
+ * Set the callback proc for a reference event.
+ */
+VALUE
+ruby_xml_sax_parser_on_reference(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, reference);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_characters { |chars| ... } => nil
+ *
+ * Set the callback proc for a characters event.
+ */
+VALUE
+ruby_xml_sax_parser_on_characters(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, characters);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_processing_instruction { |target, data| ... } => nil
+ *
+ * Set the callback proc for an processing instruction event.
+ */
+VALUE
+ruby_xml_sax_parser_on_processing_instruction(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, processingInstruction);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_comment { |msg| ... } => nil
+ *
+ * Set the callback proc for a comment event.
+ */
+VALUE
+ruby_xml_sax_parser_on_comment(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, comment);
+}
+
+
+/*
+ * call-seq:
+ *    parser.on_parser_warning { |msg| ... } => nil
+ *
+ * Set the callback proc that receives parser warnings.
+ */
+VALUE
+ruby_xml_sax_parser_on_parser_warning(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, xmlParserWarning);
+}
+ 
+ 
+/*
+ * call-seq:
+ *    parser.on_parser_error { |msg| ... } => nil
+ *
+ * Set the callback proc that receives parser errors.
+ */
+VALUE
+ruby_xml_sax_parser_on_parser_error(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, xmlParserError);
+}
+ 
+  
+/*
+ * call-seq:
+ *    parser.on_parser_fatal_error { |msg| ... } => nil
+ *
+ * Set the callback proc that receives fatal parser errors.
+ */
+VALUE
+ruby_xml_sax_parser_on_parser_fatal_error(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, xmlParserFatalError);
+}
+ 
+/*
+ * call-seq:
+ *    parser.on_cdata_block { |cdata| ... } => nil
+ *
+ * Set the callback proc for a CDATA block event.
+ */
+VALUE
+ruby_xml_sax_parser_on_cdata_block(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, cdataBlock);
+}
+ 
+/*
+ * call-seq:
+ *    parser.on_external_subset { |name, external_id, system_id| ... } => nil
+ *
+ * Set the callback proc for an external subset event.
+ */
+VALUE
+ruby_xml_sax_parser_on_external_subset(int argc, VALUE *argv, VALUE self) {
+  set_handler(self, argc, argv, externalSubset);
+}
+ 
+  
+/*
+ * call-seq:
+ *    parser.parse => (true|false)
+ * 
+ * Parse the input XML, generating callbacks to the procs
+ * registered with the parser (via the on_xxxx attributes).
+ */
+VALUE
+ruby_xml_sax_parser_parse(VALUE self) {
+  char *str;
+  int status = 1;
+  ruby_xml_sax_parser *rxsp;
+
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+
+  if (rxsp->filename != Qnil) {
+    status = xmlSAXUserParseFile(rxsp->xsh, rxsp->cbp, StringValuePtr(rxsp->filename));
+  } else if (rxsp->str != Qnil) {
+    str = StringValuePtr(rxsp->str);
+    status = //ruby_xml_document_new(cXMLDocument,
+				   xmlSAXUserParseMemory(rxsp->xsh, rxsp->cbp,
+                 str, strlen(str)); //);
+  }
+  
+  /* XXX This should return an exception for the various error codes
+   * that can come back in status, but I'm too lazy to do that right
+   * now. */
+  if (status)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string => "xml"
+ * 
+ * Obtain the parser's input string.
+ */
+VALUE
+ruby_xml_sax_parser_str_get(VALUE self) {
+  ruby_xml_sax_parser *rxsp;
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  return(rxsp->str);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string = "xml"
+ * 
+ * Set the parser's input string.
+ */
+VALUE
+ruby_xml_sax_parser_str_set(VALUE self, VALUE str) {
+  ruby_xml_sax_parser *rxsp;
+  Check_Type(str, T_STRING);
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  rxsp->str = str;
+  return(rxsp->str);
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_sax_parser(void) {
+  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
+  callsym = rb_intern("call");
+
+  rb_define_singleton_method(cXMLSaxParser, "new", ruby_xml_sax_parser_new, 0);
+
+  rb_define_method(cXMLSaxParser, "filename",
+		   ruby_xml_sax_parser_filename_get, 0);
+  rb_define_method(cXMLSaxParser, "filename=",
+		   ruby_xml_sax_parser_filename_set, 1);
+  rb_define_method(cXMLSaxParser, "parse", ruby_xml_sax_parser_parse, 0);
+  rb_define_method(cXMLSaxParser, "string", ruby_xml_sax_parser_str_get, 0);
+  rb_define_method(cXMLSaxParser, "string=", ruby_xml_sax_parser_str_set, 1);
+
+  rb_define_method(cXMLSaxParser, "on_internal_subset", 
+      ruby_xml_sax_parser_on_internal_subset, -1);        
+  rb_define_method(cXMLSaxParser, "on_is_standalone", 
+      ruby_xml_sax_parser_on_is_standalone, -1);        
+  rb_define_method(cXMLSaxParser, "on_has_internal_subset", 
+      ruby_xml_sax_parser_on_has_internal_subset, -1);        
+  rb_define_method(cXMLSaxParser, "on_has_external_subset", 
+      ruby_xml_sax_parser_on_has_external_subset, -1);        
+  rb_define_method(cXMLSaxParser, "on_start_document", 
+      ruby_xml_sax_parser_on_start_document, -1);  
+  rb_define_method(cXMLSaxParser, "on_end_document", 
+      ruby_xml_sax_parser_on_end_document, -1);  
+  rb_define_method(cXMLSaxParser, "on_start_element", 
+      ruby_xml_sax_parser_on_start_element, -1);  
+  rb_define_method(cXMLSaxParser, "on_end_element", 
+      ruby_xml_sax_parser_on_end_element, -1);        
+  rb_define_method(cXMLSaxParser, "on_reference", 
+      ruby_xml_sax_parser_on_reference, -1);        
+  rb_define_method(cXMLSaxParser, "on_characters", 
+      ruby_xml_sax_parser_on_characters, -1);        
+  rb_define_method(cXMLSaxParser, "on_processing_instruction", 
+      ruby_xml_sax_parser_on_processing_instruction, -1);        
+  rb_define_method(cXMLSaxParser, "on_comment", 
+      ruby_xml_sax_parser_on_comment, -1);        
+  rb_define_method(cXMLSaxParser, "on_parser_warning", 
+      ruby_xml_sax_parser_on_parser_warning, -1);        
+  rb_define_method(cXMLSaxParser, "on_parser_error", 
+      ruby_xml_sax_parser_on_parser_error, -1);        
+  rb_define_method(cXMLSaxParser, "on_parser_fatal_error", 
+      ruby_xml_sax_parser_on_parser_fatal_error, -1);        
+  rb_define_method(cXMLSaxParser, "on_cdata_block", 
+      ruby_xml_sax_parser_on_cdata_block, -1);        
+  rb_define_method(cXMLSaxParser, "on_external_subset", 
+      ruby_xml_sax_parser_on_external_subset, -1);              
+}

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

@@ -0,0 +1,52 @@
+/* $Id: ruby_xml_sax_parser.h,v 1.2 2006/04/14 14:45:52 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_SAX_PARSER__
+#define __RUBY_XML_SAX_PARSER__
+
+extern VALUE cXMLSaxParser;
+
+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 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