libxml-ruby 0.9.2 → 0.9.3

data/ext/libxml/ruby_xml_document.h

@@ -1,20 +1,17 @@
-/* $Id: ruby_xml_document.h 550 2008-11-17 23:26:53Z cfis $ */
+/* $Id: ruby_xml_document.h 614 2008-11-22 08:04:39Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_DOCUMENT__
-#define __RUBY_XML_DOCUMENT__
+#ifndef __rxml_DOCUMENT__
+#define __rxml_DOCUMENT__
 
 extern VALUE cXMLDocument;
 
 void ruby_init_xml_document();
-int ruby_xml_document_incr(xmlDocPtr xdoc);
-int ruby_xml_document_decr(xmlDocPtr xdoc);
 
 
 #if defined(_WIN32)
 __declspec(dllexport) 
 #endif
-VALUE ruby_xml_document_wrap(xmlDocPtr xnode);
-
+VALUE rxml_document_wrap(xmlDocPtr xnode);
 #endif

data/ext/libxml/ruby_xml_dtd.c

@@ -31,20 +31,13 @@
 VALUE cXMLDtd;
 
 void
-ruby_xml_dtd_free(ruby_xml_dtd *rxdtd) {
-  if (rxdtd->dtd != NULL) {
-    xmlFreeDtd(rxdtd->dtd);
-    rxdtd->dtd = NULL;
-  }
-
-  ruby_xfree(rxdtd);
+rxml_dtd_free(xmlDtdPtr xdtd) {
+  xmlFreeDtd(xdtd);
 }
 
-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);
+static VALUE
+rxml_dtd_alloc(VALUE klass) {
+  return Data_Wrap_Struct(klass, NULL, rxml_dtd_free, NULL);
 }
 
 /*
@@ -55,13 +48,13 @@ ruby_xml_dtd_mark(ruby_xml_dtd *rxdtd) {
  * 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;
+static VALUE
+rxml_dtd_initialize(int argc, VALUE *argv, VALUE self) {
   VALUE external, system, dtd_string;
   xmlParserInputBufferPtr buffer;
   xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
   xmlChar *new_string;
+  xmlDtdPtr xdtd;
 
   // 1 argument -- string               --> parsujeme jako dtd
   // 2 argumenty -- public, system      --> bude se hledat
@@ -71,114 +64,42 @@ ruby_xml_dtd_initialize(int argc, VALUE *argv, VALUE class) {
 
     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;
+    
+    xdtd = xmlParseDTD((xmlChar*)StringValuePtr(external),
+                       (xmlChar*)StringValuePtr(system));
 
-/*
-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
-*/
+    if (xdtd == NULL)
+      rxml_raise(&xmlLastError);
 
-  case 1:
+    DATA_PTR(self) = xdtd;
+
+    xmlSetTreeDoc((xmlNodePtr)xdtd, NULL);
+    break;
 
+  case 1:
     rb_scan_args(argc, argv, "10", &dtd_string);
+    Check_Type(dtd_string, T_STRING);
+
+    /* Note that buffer is freed by xmlParserInputBufferPush*/
     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);
+    xdtd = xmlIOParseDTD(NULL, buffer, enc);
 
-    // NOTE: For some reason freeing this InputBuffer causes a segfault! 
-    // xmlFreeParserInputBuffer(buffer); 
-    xmlFree(new_string);
+    if (xdtd == NULL)
+      rxml_raise(&xmlLastError);
 
-    return( Data_Wrap_Struct(cXMLDtd, ruby_xml_dtd_mark, ruby_xml_dtd_free, rxdtd) );
+    xmlFree(new_string);
 
+    DATA_PTR(self) = xdtd;
     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;
+  return self;
 }
 
 // Rdoc needs to know 
@@ -188,9 +109,9 @@ SV * parse_string(CLASS, str, ...)
 #endif
 
 void
-ruby_init_xml_dtd(void) {
+ruby_init_xml_dtd() {
   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);
+  rb_define_alloc_func(cXMLDtd, rxml_dtd_alloc);
+  rb_define_method(cXMLDtd, "initialize", rxml_dtd_initialize, -1);
 }
 

data/ext/libxml/ruby_xml_dtd.h

@@ -1,17 +1,8 @@
-#ifndef __RUBY_XML_DTD__
-#define __RUBY_XML_DTD__
+#ifndef __rxml_DTD__
+#define __rxml_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_error.c

@@ -44,7 +44,7 @@ static ID ERROR_HANDLER_ID;
  * error messages.
  */
 static VALUE
-ruby_xml_error_set_handler(VALUE self)
+rxml_error_set_handler(VALUE self)
 {
   VALUE block;
 
@@ -66,15 +66,15 @@ ruby_xml_error_set_handler(VALUE self)
  *
  * Removes the current error handler. */
 static VALUE
-ruby_xml_error_reset_handler(VALUE self)
+rxml_error_reset_handler(VALUE self)
 {
   rb_cvar_set(self, ERROR_HANDLER_ID, Qnil, 0);
   return self;
 }
 
 
-VALUE
-ruby_xml_error_wrap(xmlErrorPtr xerror) {
+static VALUE
+rxml_error_wrap(xmlErrorPtr xerror) {
   VALUE result = Qnil;
   if (xerror->message)
     result = rb_exc_new2(eXMLError, xerror->message);
@@ -105,7 +105,7 @@ ruby_xml_error_wrap(xmlErrorPtr xerror) {
 
   //rb_define_attr(eXMLError, "ctxt", 1, 0);
   if (xerror->node) {
-    VALUE node = ruby_xml_node2_wrap(cXMLNode, xerror->node);
+    VALUE node = rxml_node2_wrap(cXMLNode, xerror->node);
     rb_iv_set(result, "@node", node);
   }
   return result;
@@ -120,7 +120,7 @@ structuredErrorFunc(void *userData, xmlErrorPtr xerror)
 
   if (block != Qnil)
   {
-    VALUE error = ruby_xml_error_wrap(xerror);
+    VALUE error = rxml_error_wrap(xerror);
     rb_funcall(block, rb_intern("call"), 1, error);
   }
 }
@@ -132,10 +132,10 @@ structuredErrorFunc(void *userData, xmlErrorPtr xerror)
 #endif
 
 void
-ruby_xml_raise(xmlErrorPtr xerror)
+rxml_raise(xmlErrorPtr xerror)
 {
   /* Wrap error up as Ruby object and send it off to ruby */
-  VALUE error = ruby_xml_error_wrap(xerror);
+  VALUE error = rxml_error_wrap(xerror);
   rb_exc_raise(error);
 }
 
@@ -147,8 +147,8 @@ ruby_init_xml_error() {
 
   /* Error class */
   eXMLError = rb_define_class_under(mXML, "Error", rb_eStandardError);
-  rb_define_singleton_method(eXMLError, "set_handler", ruby_xml_error_set_handler, 0);
-  rb_define_singleton_method(eXMLError, "reset_handler", ruby_xml_error_reset_handler, 0);
+  rb_define_singleton_method(eXMLError, "set_handler", rxml_error_set_handler, 0);
+  rb_define_singleton_method(eXMLError, "reset_handler", rxml_error_reset_handler, 0);
 
 
   /* Ruby callback to receive errors - set it to nil by default. */

data/ext/libxml/ruby_xml_error.h

@@ -1,13 +1,13 @@
-/* $Id: ruby_xml_ns.h 324 2008-07-08 23:00:02Z cfis $ */
+/* $Id: rxml_ns.h 324 2008-07-08 23:00:02Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_ERROR__
-#define __RUBY_XML_ERROR__
+#ifndef __rxml_ERROR__
+#define __rxml_ERROR__
 
 extern VALUE eXMLError;
 
 void ruby_init_xml_error();
-void ruby_xml_raise(xmlErrorPtr xerror);
+void rxml_raise(xmlErrorPtr xerror);
 
 #endif

data/ext/libxml/ruby_xml_html_parser.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_html_parser.c 604 2008-11-19 18:01:55Z cfis $ */
+/* $Id: ruby_xml_html_parser.c 621 2008-11-22 10:17:09Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -24,48 +24,38 @@ static ID CONTEXT_ATTR;
  * 
  * Initializes a new parser instance with no pre-determined source.
  */
-VALUE
-ruby_xml_html_parser_initialize(VALUE self) {
+static VALUE
+rxml_html_parser_initialize(VALUE self) {
   VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
   rb_iv_set(self, "@input", input);
   rb_iv_set(self, "@context", Qnil);
   return self;
 }
 
-htmlParserCtxtPtr
-ruby_xml_html_parser_file_ctxt(VALUE input) {
+static htmlParserCtxtPtr
+rxml_html_parser_file_ctxt(VALUE input) {
   VALUE file = rb_ivar_get(input, FILE_ATTR);
   VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
-  VALUE encodingStr = ruby_xml_encoding_to_s(Qnil, encoding);
+  VALUE encodingStr = rxml_input_encoding_to_s(Qnil, encoding);
 
   return htmlCreateFileParserCtxt(StringValuePtr(file), StringValuePtr(encodingStr));
 }
 
-htmlParserCtxtPtr
-ruby_xml_html_parser_str_ctxt(VALUE input) {
+static htmlParserCtxtPtr
+rxml_html_parser_str_ctxt(VALUE input) {
   VALUE data = rb_ivar_get(input, STRING_ATTR);
   return htmlCreateMemoryParserCtxt(StringValuePtr(data), RSTRING_LEN(data));
 }
 
-/*
-htmlParserCtxtPtr
-ruby_xml_html_parser_io_ctxt(VALUE input) {
+/*static htmlDocPtr
+rxml_html_parser_io_ctxt(VALUE input) {
   VALUE io = rb_ivar_get(input, IO_ATTR);
   VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
   xmlCharEncoding xmlEncoding = NUM2INT(encoding);
 
-  OpenFile *fptr;
-  FILE *f;
-
-  GetOpenFile(io, fptr);
-  rb_io_check_readable(fptr);
-  f = GetWriteFile(fptr);
-
-  return htmlCreateIOParserCtxt(NULL, NULL,
-				     (xmlInputReadCallback) ctxtRead,
-				     NULL, f, xmlEncoding);
-}
-*/
+  return htmlReadIO((xmlInputReadCallback) rxml_read_callback, NULL,
+        				     io, NULL, xmlEncoding);
+}*/
 
 /*
  * call-seq:
@@ -75,8 +65,8 @@ ruby_xml_html_parser_io_ctxt(VALUE input) {
  * it's content. If an error occurs, XML::Parser::ParseError
  * is thrown.
  */
-VALUE
-ruby_xml_html_parser_parse(VALUE self) {
+static VALUE
+rxml_html_parser_parse(VALUE self) {
   xmlParserCtxtPtr ctxt;
   VALUE context;
   VALUE input = rb_ivar_get(self, INPUT_ATTR);
@@ -86,28 +76,26 @@ ruby_xml_html_parser_parse(VALUE self) {
     rb_raise(rb_eRuntimeError, "You cannot parse a data source twice");
 
   if (rb_ivar_get(input, FILE_ATTR) != Qnil)
-    ctxt = ruby_xml_html_parser_file_ctxt(input);
+    ctxt = rxml_html_parser_file_ctxt(input);
   else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
-    ctxt = ruby_xml_html_parser_str_ctxt(input);
-  /*else if (rb_ivar_get(input, DOCUMENT_ATTR) != Qnil)
-    ctxt = ruby_xml_html_parser_parse_document(input);
-  else if (rb_ivar_get(input, IO_ATTR) != Qnil)
-    ctxt = ruby_xml_html_parser_io_ctxt(input);*/
+    ctxt = rxml_html_parser_str_ctxt(input);
+  /*else if (rb_ivar_get(input, IO_ATTR) != Qnil)
+    ctxt = rxml_html_parser_io_ctxt(input);
+  else if (rb_ivar_get(input, DOCUMENT_ATTR) != Qnil)
+    ctxt = rxml_html_parser_parse_document(input);*/
   else
     rb_raise(rb_eArgError, "You must specify a parser data source");
   
   if (!ctxt)
-    ruby_xml_raise(&xmlLastError);
+    rxml_raise(&xmlLastError);
 
-  context = ruby_xml_parser_context_wrap(ctxt);
+  context = rxml_parser_context_wrap(ctxt);
   rb_ivar_set(self, CONTEXT_ATTR, context);
  
-  if (htmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) {
-    xmlFreeDoc(ctxt->myDoc);
-    ruby_xml_raise(&ctxt->lastError);
-  }
+  if (htmlParseDocument(ctxt) == -1)
+    rxml_raise(&ctxt->lastError);
 
-  return ruby_xml_document_wrap(ctxt->myDoc);
+  return rxml_document_wrap(ctxt->myDoc);
 }
 
 // Rdoc needs to know 
@@ -128,6 +116,6 @@ ruby_init_html_parser(void) {
   rb_define_attr(cXMLHTMLParser, "context", 1, 0);
 
   /* Instance methods */
-  rb_define_method(cXMLHTMLParser, "initialize", ruby_xml_html_parser_initialize, 0);
-  rb_define_method(cXMLHTMLParser, "parse", ruby_xml_html_parser_parse, 0);
+  rb_define_method(cXMLHTMLParser, "initialize", rxml_html_parser_initialize, 0);
+  rb_define_method(cXMLHTMLParser, "parse", rxml_html_parser_parse, 0);
 }

data/ext/libxml/ruby_xml_html_parser.h

@@ -1,11 +1,11 @@
-/* $Id: ruby_xml_html_parser.h 545 2008-11-17 05:29:39Z cfis $ */
+/* $Id: ruby_xml_html_parser.h 612 2008-11-21 08:01:29Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
-#ifndef __RUBY_XML_HTML_PARSER__
-#define __RUBY_XML_HTML_PARSER__
+#ifndef __rxml_HTML_PARSER__
+#define __rxml_HTML_PARSER__
 
-extern int ruby_xml_html_parser_count;
+extern int rxml_html_parser_count;
 extern VALUE cXMLHTMLParser;
 
 void ruby_init_html_parser(void);