libxml-ruby 0.8.3-x86-mswin32-60 → 0.9.0-x86-mswin32-60

data/ext/libxml/ruby_xml_error.h

@@ -0,0 +1,13 @@
+/* $Id: ruby_xml_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__
+
+extern VALUE eXMLError;
+
+void ruby_init_xml_error();
+void ruby_xml_raise(xmlErrorPtr xerror);
+
+#endif

data/ext/libxml/ruby_xml_html_parser.c

@@ -1,312 +1,72 @@
-/* $Id: ruby_xml_html_parser.c 461 2008-07-15 21:35:56Z cfis $ */
+/* $Id: ruby_xml_html_parser.c 580 2008-11-18 09:24:43Z 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));
-//}
+ID INPUT_ATTR;
+ID CONTEXT_ATTR;
 
 
 /*
- * 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;
+* Document-class: LibXML::XML::HTMLParser
+*
+* The HTML parser implements an HTML 4.0 non-verifying parser with an API 
+* compatible with the XML::Parser.  In contrast with the XML::Parser, 
+* it can parse "real world" HTML, even if it severely broken from a
+* specification point of view. */
 
-  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"
+ *    XML::HTMLParser.initialize -> parser
  * 
- * Set the filename this parser will read from.
+ * Initializes a new parser instance with no pre-determined source.
  */
-/*
 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_new();
-  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);
+ruby_xml_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;
 }
-*/
 
-void
-ruby_xml_html_parser_free(ruby_xml_html_parser *rxp) {
-  void *data;
+htmlParserCtxtPtr
+ruby_xml_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);
 
-  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);
+  return htmlCreateFileParserCtxt(StringValuePtr(file), StringValuePtr(encodingStr));
 }
 
-
-/*
- * 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);
+htmlParserCtxtPtr
+ruby_xml_html_parser_str_ctxt(VALUE input) {
+  VALUE data = rb_ivar_get(input, STRING_ATTR);
+  return htmlCreateMemoryParserCtxt(StringValuePtr(data), RSTRING_LEN(data));
 }
-*/
 
 /*
- * 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;
+htmlParserCtxtPtr
+ruby_xml_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;
 
-  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_new();
-  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,
+  return htmlCreateIOParserCtxt(NULL, NULL,
 				     (xmlInputReadCallback) ctxtRead,
-				     NULL, f, XML_CHAR_ENCODING_NONE);
-  if (NIL_P(rxpc->ctxt))
-    rb_sys_fail(0);
-
-  return(data->io);
+				     NULL, f, xmlEncoding);
 }
 */
 
-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);
-
-  rb_gc_mark(LIBXML_STATE);
-
-  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
@@ -317,111 +77,39 @@ ruby_xml_html_parser_new_string(VALUE class, VALUE str) {
  */
 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);
+  xmlParserCtxtPtr ctxt;
+  VALUE context;
+  VALUE input = rb_ivar_get(self, INPUT_ATTR);
+
+  context = rb_ivar_get(self, CONTEXT_ATTR);
+  if (context != Qnil)
+    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);
+  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);*/
   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);
+    rb_raise(rb_eArgError, "You must specify a parser data source");
+  
+  if (!ctxt)
+    ruby_xml_raise(&xmlLastError);
+
+  context = ruby_xml_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);
   }
 
-  rxp->ctxt = ruby_xml_parser_context_new();
-  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);
+  return ruby_xml_document_wrap(ctxt->myDoc);
 }
 
-
 // Rdoc needs to know 
 #ifdef RDOC_NEVER_DEFINED
   mLibXML = rb_define_module("LibXML");
@@ -430,20 +118,16 @@ ruby_xml_html_parser_str_set(VALUE self, VALUE str) {
 
 void
 ruby_init_html_parser(void) {	
+  INPUT_ATTR = rb_intern("@input");
+  CONTEXT_ATTR = rb_intern("@context");
+
   cXMLHTMLParser = rb_define_class_under(mXML, "HTMLParser", rb_cObject);
+ 
+  /* Atributes */
+  rb_define_attr(cXMLHTMLParser, "input", 1, 0);
+  rb_define_attr(cXMLHTMLParser, "context", 1, 0);
 
-  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_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_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);
-  */
+  /* 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, "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);  
 }