libxml-ruby 0.6.0-x86-mswin32-60

data/ext/libxml/ruby_xml_document.h

@@ -0,0 +1,27 @@
+/* $Id: ruby_xml_document.h 304 2008-07-02 17:42:41Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_DOCUMENT__
+#define __RUBY_XML_DOCUMENT__
+
+extern VALUE cXMLDocument;
+
+typedef struct rxp_document {
+  xmlDocPtr doc;   /* Tree/DOM interface */
+  int data_type;   /* The data type referenced by *data */
+  void *data;      /* Pointer to an external structure of options */
+} ruby_xml_document_t;
+
+VALUE ruby_xml_document_filename_get(VALUE self);
+VALUE ruby_xml_document_new_native(VALUE class, VALUE xmlver);
+void  ruby_xml_document_free(ruby_xml_document_t *rxd);
+VALUE ruby_xml_document_root_get(VALUE self);
+void  ruby_init_xml_document(void);
+
+#if defined(_WIN32)
+__declspec(dllexport) 
+#endif
+VALUE ruby_xml_document_wrap(xmlDocPtr xnode);
+
+#endif

data/ext/libxml/ruby_xml_dtd.c

@@ -0,0 +1,168 @@
+#include "ruby_libxml.h"
+#include "ruby_xml_dtd.h"
+
+VALUE cXMLDtd;
+
+void
+ruby_xml_dtd_free(ruby_xml_dtd *rxdtd) {
+  if (rxdtd->dtd != NULL) {
+    xmlFreeDtd(rxdtd->dtd);
+    rxdtd->dtd = NULL;
+  }
+
+  ruby_xfree(rxdtd);
+}
+
+static void
+ruby_xml_dtd_mark(ruby_xml_dtd *rxdtd) {
+  return;
+  //if (rxdtd == NULL) return;
+  //if (!NIL_P(rxd->xmlver)) rb_gc_mark(rxd->xmlver);
+}
+
+/*
+ * call-seq:
+ *    XML::Dtd.new("public system") => dtd
+ *    XML::Dtd.new("public", "system") => dtd
+ * 
+ * Create a new Dtd from the specified public and system
+ * identifiers.
+ */
+VALUE
+ruby_xml_dtd_initialize(int argc, VALUE *argv, VALUE class) {
+  ruby_xml_dtd *rxdtd;
+  VALUE external, system, dtd_string;
+  xmlParserInputBufferPtr buffer;
+  xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+  xmlChar *new_string;
+
+  // 1 argument -- string               --> parsujeme jako dtd
+  // 2 argumenty -- public, system      --> bude se hledat
+  switch (argc) {
+  case 2:
+    rb_scan_args(argc, argv, "20", &external, &system);
+
+    Check_Type(external, T_STRING);
+    Check_Type(system,   T_STRING);
+    rxdtd = ALLOC(ruby_xml_dtd);
+    rxdtd->dtd = xmlParseDTD( (xmlChar*)StringValuePtr(external),
+                              (xmlChar*)StringValuePtr(system) );
+    if (rxdtd->dtd == NULL) {
+      ruby_xfree(rxdtd);
+      return(Qfalse);
+    }
+
+    xmlSetTreeDoc( (xmlNodePtr)rxdtd->dtd, NULL );
+    return( Data_Wrap_Struct(cXMLDtd, ruby_xml_dtd_mark, ruby_xml_dtd_free, rxdtd) );
+    break;
+
+/*
+SV *
+new(CLASS, external, system)
+        char * CLASS
+        char * external
+        char * system
+    ALIAS:
+        parse_uri = 1
+    PREINIT:
+        xmlDtdPtr dtd = NULL;
+    CODE:
+        LibXML_error = sv_2mortal(newSVpv("", 0));
+        dtd = xmlParseDTD((const xmlChar*)external, (const xmlChar*)system);
+        if ( dtd == NULL ) {
+            XSRETURN_UNDEF;
+        }
+        xmlSetTreeDoc((xmlNodePtr)dtd, NULL);
+        RETVAL = PmmNodeToSv( (xmlNodePtr) dtd, NULL );
+    OUTPUT:
+        RETVAL
+*/
+
+  case 1:
+
+    rb_scan_args(argc, argv, "10", &dtd_string);
+    buffer = xmlAllocParserInputBuffer(enc);
+    //if ( !buffer) return Qnil
+    new_string = xmlStrdup((xmlChar*)StringValuePtr(dtd_string));
+    xmlParserInputBufferPush(buffer, xmlStrlen(new_string), (const char*)new_string);
+
+    rxdtd = ALLOC(ruby_xml_dtd);
+    rxdtd->dtd = xmlIOParseDTD(NULL, buffer, enc);
+
+    // NOTE: For some reason freeing this InputBuffer causes a segfault! 
+    // xmlFreeParserInputBuffer(buffer); 
+    xmlFree(new_string);
+
+    return( Data_Wrap_Struct(cXMLDtd, ruby_xml_dtd_mark, ruby_xml_dtd_free, rxdtd) );
+
+    break;
+/*
+SV * parse_string(CLASS, str, ...)
+        char * CLASS
+        char * str
+    PREINIT:
+        STRLEN n_a;
+        xmlDtdPtr res;
+        SV * encoding_sv;
+        xmlParserInputBufferPtr buffer;
+        xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+        xmlChar * new_string;
+        STRLEN len;
+    CODE:
+        LibXML_init_error();
+        if (items > 2) {
+            encoding_sv = ST(2);
+            if (items > 3) {
+                croak("parse_string: too many parameters");
+            }
+            // warn("getting encoding...\n"); 
+            enc = xmlParseCharEncoding(SvPV(encoding_sv, n_a));
+            if (enc == XML_CHAR_ENCODING_ERROR) {
+                croak("Parse of encoding %s failed: %s", SvPV(encoding_sv, n_a), SvPV(LibXML_error, n_a));
+            }
+        }
+        buffer = xmlAllocParserInputBuffer(enc);
+        // buffer = xmlParserInputBufferCreateMem(str, xmlStrlen(str), enc); 
+        if ( !buffer)
+            croak("cant create buffer!\n" );
+
+        new_string = xmlStrdup((const xmlChar*)str);
+        xmlParserInputBufferPush(buffer, xmlStrlen(new_string), (const char*)new_string);
+
+        res = xmlIOParseDTD(NULL, buffer, enc);
+
+        // NOTE: For some reason freeing this InputBuffer causes a segfault! 
+        // xmlFreeParserInputBuffer(buffer); 
+        xmlFree(new_string);
+
+        sv_2mortal( LibXML_error );
+        LibXML_croak_error();
+
+        if (res == NULL) {
+            croak("no DTD parsed!");
+        }
+        RETVAL = PmmNodeToSv((xmlNodePtr)res, NULL);
+    OUTPUT:
+        RETVAL
+ */
+    
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)");
+  }
+
+  //docobj = ruby_xml_document_new2(cXMLDocument, xmlver);
+  return Qnil;
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_dtd(void) {
+  cXMLDtd = rb_define_class_under(mXML, "Dtd", rb_cObject);
+  rb_define_singleton_method(cXMLDtd, "new", ruby_xml_dtd_initialize, -1);
+  //rb_define_method(cXMLDocument, "xinclude", ruby_xml_document_xinclude, 0);
+}
+

data/ext/libxml/ruby_xml_dtd.h

@@ -0,0 +1,17 @@
+#ifndef __RUBY_XML_DTD__
+#define __RUBY_XML_DTD__
+
+extern VALUE cXMLDtd;
+
+typedef struct rxp_dtd {
+  xmlDtdPtr dtd;   /* DTD interface */
+  //int data_type;   /* The data type referenced by *data */
+  //void *data;      /* Pointer to an external structure of options */
+  //int is_ptr;      /* Determines if this object owns its data or points to it someplace else */
+  //VALUE xmlver;    /* T_STRING with the xml version */
+} ruby_xml_dtd;
+
+void  ruby_init_xml_dtd(void);
+void  ruby_dtd_free(ruby_xml_dtd *rxdtd);
+
+#endif

data/ext/libxml/ruby_xml_html_parser.c

@@ -0,0 +1,449 @@
+/* $Id: ruby_xml_html_parser.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+
+VALUE cXMLHTMLParser;
+
+//static int
+//ctxtRead(FILE *f, char * buf, int len) {
+//    return(fread(buf, 1, len, f));
+//}
+
+
+/*
+ * call-seq:
+ *    parser.filename => "filename"
+ * 
+ * Obtain the filename this parser will read from.
+ */
+ /*
+VALUE
+ruby_xml_html_parser_filename_get(VALUE self) {
+  ruby_xml_html_parser *rxp;
+  rx_file_data *data;
+
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+  if (rxp->data == NULL)
+    return(Qnil);
+
+  if (rxp->data_type != RUBY_LIBXML_SRC_TYPE_FILE)
+    return(Qnil);
+
+  data = (rx_file_data *)rxp->data;
+  return(data->filename);
+}
+*/
+
+/*
+ * call-seq:
+ *    parser.filename = "filename"
+ * 
+ * Set the filename this parser will read from.
+ */
+/*
+VALUE
+ruby_xml_html_parser_filename_set(VALUE self, VALUE filename) {
+  ruby_xml_html_parser *rxp;
+  ruby_xml_parser_context *rxpc;
+  rx_file_data *data;
+
+  Check_Type(filename, T_STRING);
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+
+  if (rxp->data_type == RUBY_LIBXML_SRC_TYPE_NULL) {
+    if (rxp->data != NULL)
+      rb_fatal("crap, this should be null");
+
+    rxp->data_type = RUBY_LIBXML_SRC_TYPE_FILE;
+    data = ALLOC(rx_file_data);
+    rxp->data = data;
+  } else if (rxp->data_type != RUBY_LIBXML_SRC_TYPE_FILE) {
+    return(Qnil);
+  }
+
+  rxp->ctxt = ruby_xml_parser_context_new3();
+  data = (rx_file_data *)rxp->data;
+  data->filename = filename;
+
+  Data_Get_Struct(rxp->ctxt, ruby_xml_parser_context, rxpc);
+  rxpc->ctxt = htmlCreateFileParserCtxt(StringValuePtr(filename));
+  if (rxpc->ctxt == NULL)
+    rb_sys_fail(StringValuePtr(filename));
+
+  return(data->filename);
+}
+*/
+
+void
+ruby_xml_html_parser_free(ruby_xml_html_parser *rxp) {
+  void *data;
+
+  switch(rxp->data_type) {
+  case RUBY_LIBXML_SRC_TYPE_NULL:
+    break;
+  case RUBY_LIBXML_SRC_TYPE_FILE:
+    data = (void *)(rx_file_data *)rxp->data;
+    ruby_xfree((rx_file_data *)data);
+    break;
+  case RUBY_LIBXML_SRC_TYPE_STRING:
+    data = (void *)(rx_string_data *)rxp->data;
+    ruby_xfree((rx_string_data *)data);
+    break;
+  case RUBY_LIBXML_SRC_TYPE_IO:
+    data = (void *)(rx_io_data *)rxp->data;
+    ruby_xfree((rx_io_data *)data);
+    break;
+  default:
+    rb_fatal("Unknown data type, %d", rxp->data_type);
+  }
+
+  ruby_xfree(rxp);
+}
+
+
+/*
+ * call-seq:
+ *    parser.io => IO
+ * 
+ * Obtain the IO instance this parser works with.
+ */
+ /*
+VALUE
+ruby_xml_html_parser_io_get(VALUE self, VALUE io) {
+  ruby_xml_html_parser *rxp;
+  rx_io_data *data;
+
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+
+  if (rxp->data_type == RUBY_LIBXML_SRC_TYPE_NULL ||
+      rxp->data_type != RUBY_LIBXML_SRC_TYPE_IO ||
+      rxp->data == NULL)
+    return(Qnil);
+
+  data = (rx_io_data *)rxp->data;
+
+  return(data->io);
+}
+*/
+
+/*
+ * call-seq:
+ *    parser.io = IO
+ * 
+ * Set the IO instance this parser works with.
+ */
+ /*
+VALUE
+ruby_xml_html_parser_io_set(VALUE self, VALUE io) {
+  ruby_xml_html_parser *rxp;
+  ruby_xml_parser_context *rxpc;
+  rx_io_data *data;
+  OpenFile *fptr;
+  FILE *f;
+
+  if (!rb_obj_is_kind_of(io, rb_cIO))
+    rb_raise(rb_eTypeError, "need an IO object");
+
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+
+  if (rxp->data_type == RUBY_LIBXML_SRC_TYPE_NULL) {
+    if (rxp->data != NULL)
+      rb_fatal("crap, this should be null");
+
+    rxp->data_type = RUBY_LIBXML_SRC_TYPE_IO;
+    data = ALLOC(rx_io_data);
+    rxp->data = data;
+  } else if (rxp->data_type != RUBY_LIBXML_SRC_TYPE_IO) {
+    return(Qnil);
+  }
+
+  rxp->ctxt = ruby_xml_parser_context_new3();
+  data = (rx_io_data *)rxp->data;
+  data->io = io;
+
+  GetOpenFile(io, fptr);
+  rb_io_check_readable(fptr);
+  f = GetWriteFile(fptr);
+
+  Data_Get_Struct(rxp->ctxt, ruby_xml_parser_context, rxpc);
+  rxpc->ctxt = htmlCreateIOParserCtxt(NULL, NULL,
+				     (xmlInputReadCallback) ctxtRead,
+				     NULL, f, XML_CHAR_ENCODING_NONE);
+  if (NIL_P(rxpc->ctxt))
+    rb_sys_fail(0);
+
+  return(data->io);
+}
+*/
+
+void
+ruby_xml_html_parser_mark(ruby_xml_html_parser *rxp) {
+  if (rxp == NULL) return;
+  if (!NIL_P(rxp->ctxt)) rb_gc_mark(rxp->ctxt);
+
+  ruby_xml_state_marker();
+
+  switch(rxp->data_type) {
+  case RUBY_LIBXML_SRC_TYPE_NULL:
+    break;
+  case RUBY_LIBXML_SRC_TYPE_FILE:
+    if (!NIL_P(((rx_file_data *)rxp->data)->filename))
+      rb_gc_mark(((rx_file_data *)rxp->data)->filename);
+    break;
+  case RUBY_LIBXML_SRC_TYPE_STRING:
+    if (!NIL_P(((rx_string_data *)rxp->data)->str))
+      rb_gc_mark(((rx_string_data *)rxp->data)->str);
+    break;
+  case RUBY_LIBXML_SRC_TYPE_IO:
+    if (!NIL_P(((rx_io_data *)rxp->data)->io))
+      rb_gc_mark(((rx_io_data *)rxp->data)->io);
+    break;
+  default:
+    rb_fatal("unknown datatype: %d", rxp->data_type);
+  }
+}
+
+
+/*
+ * call-seq:
+ *    XML::HTMLParser.new => parser
+ * 
+ * Create a new parser instance with no pre-determined source.
+ */
+VALUE
+ruby_xml_html_parser_new(VALUE class) {
+  ruby_xml_html_parser *rxp;
+
+  rxp = ALLOC(ruby_xml_html_parser);
+  rxp->ctxt = Qnil;
+  rxp->data_type = RUBY_LIBXML_SRC_TYPE_NULL;
+  rxp->data = NULL;
+  rxp->parsed = 0;
+
+  return(Data_Wrap_Struct(class, ruby_xml_html_parser_mark,
+			  ruby_xml_html_parser_free, rxp));
+}
+
+
+/*
+ * call-seq:
+ *    XML::HTMLParser.file => parser
+ * 
+ * Create a new parser instance that will read the specified file.
+ */
+ /*
+VALUE
+ruby_xml_html_parser_new_file(VALUE class, VALUE filename) {
+  VALUE obj;
+  ruby_xml_html_parser *rxp;
+  rx_file_data *data;
+
+  obj = ruby_xml_html_parser_new(class);
+  Data_Get_Struct(obj, ruby_xml_html_parser, rxp);
+
+  data = ALLOC(rx_file_data);
+  rxp->data_type = RUBY_LIBXML_SRC_TYPE_FILE;
+  rxp->data = data;
+
+  ruby_xml_html_parser_filename_set(obj, filename);
+
+  return(obj);
+}
+*/
+
+/*
+ * call-seq:
+ *    XML::HTMLParser.io => parser
+ * 
+ * Create a new parser instance that will read from the
+ * specified IO object.
+ */
+ /*
+VALUE
+ruby_xml_html_parser_new_io(VALUE class, VALUE io) {
+  VALUE obj;
+  ruby_xml_html_parser *rxp;
+  rx_io_data *data;
+
+  obj = ruby_xml_html_parser_new(class);
+  Data_Get_Struct(obj, ruby_xml_html_parser, rxp);
+
+  data = ALLOC(rx_io_data);
+  rxp->data_type = RUBY_LIBXML_SRC_TYPE_IO;
+  rxp->data = data;
+
+  ruby_xml_html_parser_io_set(obj, io);
+
+  return(obj);
+}
+*/
+
+/*
+ * call-seq:
+ *    XML::HTMLParser.string => parser
+ * 
+ * Create a new parser instance that will parse the given
+ * string.
+ */
+VALUE
+ruby_xml_html_parser_new_string(VALUE class, VALUE str) {
+  VALUE obj;
+  ruby_xml_html_parser *rxp;
+  rx_string_data *data;
+
+  obj = ruby_xml_html_parser_new(class);
+  Data_Get_Struct(obj, ruby_xml_html_parser, rxp);
+
+  data = ALLOC(rx_string_data);
+  rxp->data_type = RUBY_LIBXML_SRC_TYPE_STRING;
+  rxp->data = data;
+
+  ruby_xml_html_parser_str_set(obj, str);
+
+  return(obj);
+}
+
+
+/*
+ * call-seq:
+ *    parser.parse => document
+ * 
+ * Parse the input XML and create an XML::Document with
+ * it's content. If an error occurs, XML::Parser::ParseError
+ * is thrown.
+ */
+VALUE
+ruby_xml_html_parser_parse(VALUE self) {
+  ruby_xml_html_parser *rxp;
+  ruby_xml_parser_context *rxpc;
+  htmlDocPtr xdp;
+  VALUE doc;
+
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+
+  switch (rxp->data_type) {
+  case RUBY_LIBXML_SRC_TYPE_NULL:
+    return(Qnil);
+  case RUBY_LIBXML_SRC_TYPE_STRING:
+  //case RUBY_LIBXML_SRC_TYPE_FILE:
+  //case RUBY_LIBXML_SRC_TYPE_IO:
+    Data_Get_Struct(rxp->ctxt, ruby_xml_parser_context, rxpc);
+    
+    /* don't check return values here, the HTML parser returns errors
+     * but still allows the resulting tree to be used.
+     */
+    htmlParseDocument(rxpc->ctxt);
+    xdp = rxpc->ctxt->myDoc;
+    rxp->parsed = 1;
+
+    doc = ruby_xml_document_wrap(xdp);
+    break;
+  default:
+    rb_fatal("Unknown data type, %d", rxp->data_type);
+  }
+
+  return(doc);
+}
+
+
+/*
+ * call-seq:
+ *    parser.context => context
+ * 
+ * Obtain the XML::Parser::Context associated with this
+ * parser.
+ */
+VALUE
+ruby_xml_html_parser_context_get(VALUE self) {
+  ruby_xml_html_parser *rxp;
+
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+  if (rxp->ctxt == Qnil)
+    return(Qnil);
+  else
+    return(rxp->ctxt);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string => "string"
+ * 
+ * Obtain the string this parser works with.
+ */
+VALUE
+ruby_xml_html_parser_str_get(VALUE self) {
+  ruby_xml_html_parser *rxp;
+  rx_string_data *data;
+
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+  if (rxp->data == NULL || rxp->data_type != RUBY_LIBXML_SRC_TYPE_STRING)
+    return(Qnil);
+
+  data = (rx_string_data *)rxp->data;
+  return(data->str);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string = "string"
+ * 
+ * Set the string this parser works with.
+ */
+VALUE
+ruby_xml_html_parser_str_set(VALUE self, VALUE str) {
+  ruby_xml_html_parser *rxp;
+  ruby_xml_parser_context *rxpc;
+  rx_string_data *data;
+
+  Check_Type(str, T_STRING);
+  Data_Get_Struct(self, ruby_xml_html_parser, rxp);
+
+  if (rxp->data_type == RUBY_LIBXML_SRC_TYPE_NULL) {
+    rxp->data_type = RUBY_LIBXML_SRC_TYPE_STRING;
+    data = ALLOC(rx_string_data);
+    rxp->data = data;
+  } else if (rxp->data_type != RUBY_LIBXML_SRC_TYPE_STRING) {
+    return(Qnil);
+  }
+
+  rxp->ctxt = ruby_xml_parser_context_new3();
+  data = (rx_string_data *)rxp->data;
+  data->str = str;
+
+  Data_Get_Struct(rxp->ctxt, ruby_xml_parser_context, rxpc);
+  rxpc->ctxt = htmlCreateMemoryParserCtxt(StringValuePtr(data->str), RSTRING_LEN(data->str));
+
+  return(data->str);
+}
+
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_html_parser(void) {	
+  cXMLHTMLParser = rb_define_class_under(mXML, "HTMLParser", rb_cObject);
+
+  /*                
+  rb_define_singleton_method(cXMLHTMLParser, "file", ruby_xml_html_parser_new_file, 1);
+  rb_define_singleton_method(cXMLHTMLParser, "io", ruby_xml_html_parser_new_io, 1);
+  */
+  rb_define_singleton_method(cXMLHTMLParser, "new", ruby_xml_html_parser_new, 0);
+  rb_define_singleton_method(cXMLHTMLParser, "string", ruby_xml_html_parser_new_string, 1);
+  /*
+  rb_define_method(cXMLHTMLParser, "filename", ruby_xml_html_parser_filename_get, 0);
+  rb_define_method(cXMLHTMLParser, "filename=", ruby_xml_html_parser_filename_set, 1);
+  rb_define_method(cXMLHTMLParser, "io", ruby_xml_html_parser_io_get, 0);
+  rb_define_method(cXMLHTMLParser, "io=", ruby_xml_html_parser_io_set, 1);
+  */
+  rb_define_method(cXMLHTMLParser, "parse", ruby_xml_html_parser_parse, 0);
+  rb_define_method(cXMLHTMLParser, "context", ruby_xml_html_parser_context_get, 0);
+  rb_define_method(cXMLHTMLParser, "string", ruby_xml_html_parser_str_get, 0);
+  rb_define_method(cXMLHTMLParser, "string=", ruby_xml_html_parser_str_set, 1);  
+}