libxml-ruby 0.9.2 → 0.9.3

data/ext/libxml/ruby_xml_reader.h

@@ -1,14 +1,14 @@
 /* Copyright (c) 2006 Apple Computer Inc.
  * Please see the LICENSE file for copyright and distribution information. */
 
-#ifndef __RUBY_XML_READER__
-#define __RUBY_XML_READER__
+#ifndef __rxml_READER__
+#define __rxml_READER__
 
 extern VALUE cXMLReader;
 
 void ruby_init_xml_reader(void);
 
 /* Exported to be used by XML::Document#reader */
-VALUE ruby_xml_reader_new_walker(VALUE self, VALUE doc);
+VALUE rxml_reader_new_walker(VALUE self, VALUE doc);
 
-#endif /* __RUBY_XML_READER__ */
+#endif /* __rxml_READER__ */

data/ext/libxml/ruby_xml_relaxng.c

@@ -39,18 +39,8 @@ VALUE cXMLRelaxNG;
 #endif
 
 static void
-ruby_xml_relaxng_mark(ruby_xml_relaxng *rxrelaxng) {
-  return;
-}
-
-void
-ruby_xml_relaxng_free(ruby_xml_relaxng *rxrelaxng) {
-  if (rxrelaxng->relaxng != NULL) {
-    xmlRelaxNGFree(rxrelaxng->relaxng);
-    rxrelaxng->relaxng = NULL;
-  }
-
-  ruby_xfree(rxrelaxng);
+rxml_relaxng_free(xmlRelaxNGPtr xrelaxng) {
+  xmlRelaxNGFree(xrelaxng);
 }
 
 /*
@@ -59,19 +49,18 @@ ruby_xml_relaxng_free(ruby_xml_relaxng *rxrelaxng) {
  * 
  * Create a new relaxng from the specified URI.
  */
-VALUE
-ruby_xml_relaxng_init_from_uri(VALUE class, VALUE uri) {
-  xmlRelaxNGParserCtxtPtr parser;
-  ruby_xml_relaxng *relaxng;
+static VALUE
+rxml_relaxng_init_from_uri(VALUE class, VALUE uri) {
+  xmlRelaxNGParserCtxtPtr xparser;
+  xmlRelaxNGPtr xrelaxng;
 
   Check_Type(uri, T_STRING);
 
-  parser = xmlRelaxNGNewParserCtxt(StringValuePtr(uri));
-  relaxng = ALLOC(ruby_xml_relaxng);
-  relaxng->relaxng = xmlRelaxNGParse(parser);
-  xmlRelaxNGFreeParserCtxt(parser);
+  xparser = xmlRelaxNGNewParserCtxt(StringValuePtr(uri));
+  xrelaxng = xmlRelaxNGParse(xparser);
+  xmlRelaxNGFreeParserCtxt(xparser);
 
-  return Data_Wrap_Struct(cXMLRelaxNG, ruby_xml_relaxng_mark, ruby_xml_relaxng_free, relaxng);
+  return Data_Wrap_Struct(cXMLRelaxNG, NULL, rxml_relaxng_free, xrelaxng);
 }
 
 /*
@@ -80,20 +69,19 @@ ruby_xml_relaxng_init_from_uri(VALUE class, VALUE uri) {
  * 
  * Create a new relaxng from the specified document.
  */
-VALUE
-ruby_xml_relaxng_init_from_document(VALUE class, VALUE document) {
+static VALUE
+rxml_relaxng_init_from_document(VALUE class, VALUE document) {
   xmlDocPtr xdoc;
-  ruby_xml_relaxng *relaxng;
-  xmlRelaxNGParserCtxtPtr parser;
+  xmlRelaxNGPtr xrelaxng;
+  xmlRelaxNGParserCtxtPtr xparser;
 
   Data_Get_Struct(document, xmlDoc, xdoc);
 
-  parser = xmlRelaxNGNewDocParserCtxt(xdoc);
-  relaxng = ALLOC(ruby_xml_relaxng);
-  relaxng->relaxng = xmlRelaxNGParse(parser);
-  xmlRelaxNGFreeParserCtxt(parser);
+  xparser = xmlRelaxNGNewDocParserCtxt(xdoc);
+  xrelaxng = xmlRelaxNGParse(xparser);
+  xmlRelaxNGFreeParserCtxt(xparser);
 
-  return Data_Wrap_Struct(cXMLRelaxNG, ruby_xml_relaxng_mark, ruby_xml_relaxng_free, relaxng);
+  return Data_Wrap_Struct(cXMLRelaxNG, NULL, rxml_relaxng_free, xrelaxng);
 }
 
 /*
@@ -102,25 +90,24 @@ ruby_xml_relaxng_init_from_document(VALUE class, VALUE document) {
  * 
  * Create a new relaxng using the specified string.
  */
-VALUE
-ruby_xml_relaxng_init_from_string(VALUE self, VALUE relaxng_str) {
-  xmlRelaxNGParserCtxtPtr  parser;
-  ruby_xml_relaxng *rxrelaxng;
+static VALUE
+rxml_relaxng_init_from_string(VALUE self, VALUE relaxng_str) {
+  xmlRelaxNGParserCtxtPtr  xparser;
+  xmlRelaxNGPtr xrelaxng;
 
   Check_Type(relaxng_str, T_STRING);
 
-  parser = xmlRelaxNGNewMemParserCtxt(StringValuePtr(relaxng_str), strlen(StringValuePtr(relaxng_str)));
-  rxrelaxng = ALLOC(ruby_xml_relaxng);
-  rxrelaxng->relaxng = xmlRelaxNGParse(parser);
-  xmlRelaxNGFreeParserCtxt(parser);
+  xparser = xmlRelaxNGNewMemParserCtxt(StringValuePtr(relaxng_str), strlen(StringValuePtr(relaxng_str)));
+  xrelaxng = xmlRelaxNGParse(xparser);
+  xmlRelaxNGFreeParserCtxt(xparser);
 
-  return Data_Wrap_Struct(cXMLRelaxNG, ruby_xml_relaxng_mark, ruby_xml_relaxng_free, rxrelaxng);
+  return Data_Wrap_Struct(cXMLRelaxNG, NULL, rxml_relaxng_free, xrelaxng);
 }
   
-void  ruby_init_xml_relaxng(void) {
+void ruby_init_xml_relaxng(void) {
   cXMLRelaxNG = rb_define_class_under(mXML, "RelaxNG", rb_cObject);
-  rb_define_singleton_method(cXMLRelaxNG, "new",         ruby_xml_relaxng_init_from_uri, 1);
-  rb_define_singleton_method(cXMLRelaxNG, "from_string", ruby_xml_relaxng_init_from_string, 1);
-  rb_define_singleton_method(cXMLRelaxNG, "document",    ruby_xml_relaxng_init_from_document, 1);
+  rb_define_singleton_method(cXMLRelaxNG, "new",         rxml_relaxng_init_from_uri, 1);
+  rb_define_singleton_method(cXMLRelaxNG, "from_string", rxml_relaxng_init_from_string, 1);
+  rb_define_singleton_method(cXMLRelaxNG, "document",    rxml_relaxng_init_from_document, 1);
 }
 

data/ext/libxml/ruby_xml_relaxng.h

@@ -1,15 +1,10 @@
-#ifndef __RUBY_XML_RELAXNG__
-#define __RUBY_XML_RELAXNG__
+#ifndef __rxml_RELAXNG__
+#define __rxml_RELAXNG__
 
 #include <libxml/relaxng.h>
 
 extern VALUE cXMLRelaxNG;
 
-typedef struct rxp_relaxng {
-  xmlRelaxNGPtr relaxng;   /* RelaxNG interface */
-} ruby_xml_relaxng;
-
 void  ruby_init_xml_relaxng(void);
-void  ruby_relaxng_free(ruby_xml_relaxng *rxs);
 #endif
 

data/ext/libxml/ruby_xml_sax_parser.c

@@ -1,228 +1,174 @@
-/* $Id: ruby_xml_sax_parser.c 604 2008-11-19 18:01:55Z cfis $ */
-
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include "ruby_libxml.h"
-#include "ruby_xml_sax_parser.h"
-
-/*
- * Document-class: LibXML::XML::SaxParser
- *
- * XML::SaxParser provides a callback based API for parsing documents,
- * in contrast to XML::Parser's tree based API and XML::Reader's stream
- * based API.  
- *
- * Note that the XML::SaxParser API is fairly complex, not well standardized, 
- * and does not directly support validation making entity, namespace and
- * base processing relatively hard.
- *
- * To use the XML::SaxParser, register a callback class via the
- * XML::SaxParser#callbacks=.  It is easiest to include the 
- * XML::SaxParser::Callbacks module in your class and override 
- * the methods as needed.
- *
- * Basic example:
- *
- *   class MyCallbacks
- *     include XML::SaxParser::Callbacks
- *     def on_start_element(element, attributes)
- *       puts #Element started: #{element}"
- *     end
- *   end
- *
- *   parser = XML::SaxParser.new
- *   parser.callbacks = MyCallbacks.new
- *   parser.parse
- */
-
-VALUE cXMLSaxParser;
-VALUE mXMLSaxParserCallbacks;
-
-static ID INPUT_ATTR;
-
-VALUE cbidOnInternalSubset;
-VALUE cbidOnIsStandalone;
-VALUE cbidOnHasInternalSubset;
-VALUE cbidOnHasExternalSubset;
-VALUE cbidOnStartDocument;
-VALUE cbidOnEndDocument;
-VALUE cbidOnStartElement;
-VALUE cbidOnEndElement;
-VALUE cbidOnReference;
-VALUE cbidOnCharacters;
-VALUE cbidOnProcessingInstruction;
-VALUE cbidOnComment;
-VALUE cbidOnXmlParserWarning;
-VALUE cbidOnXmlParserError;
-VALUE cbidOnXmlParserFatalError;
-VALUE cbidOnCdataBlock;
-VALUE cbidOnExternalSubset;
-
-#include "sax_parser_callbacks.inc"
-
-void
-ruby_xml_sax_parser_free(ruby_xml_sax_parser *rxsp) {
-  xfree(rxsp);
-}
-
-void
-ruby_xml_sax_parser_mark(ruby_xml_sax_parser *rxsp) {
-  if (rxsp->callbackHandler != Qnil) {
-    rb_gc_mark(rxsp->callbackHandler);
-  }
-  
-  if (rxsp->filename != Qnil) {
-    rb_gc_mark(rxsp->filename);
-  }
-
-  if (rxsp->str != Qnil) {
-    rb_gc_mark(rxsp->str);
-  }
-}
-
-VALUE
-ruby_xml_sax_parser_alloc(VALUE klass) {
-  ruby_xml_sax_parser *rxsp = ALLOC(ruby_xml_sax_parser);
-  rxsp->xsh = &rubySAXHandlerStruct;
-  rxsp->callbackHandler = Qnil;  
-  rxsp->xpc = NULL;
-  rxsp->filename = Qnil;
-  rxsp->str = Qnil;
-
-  return Data_Wrap_Struct(cXMLSaxParser, 
-                          ruby_xml_sax_parser_mark, ruby_xml_sax_parser_free,
-                          rxsp);
-}
-
-
-/*
- * call-seq:
- *    sax_parser.initialize -> sax_parser
- * 
- * Initiliazes instance of parser.
- */
-VALUE
-ruby_xml_sax_parser_initialize(VALUE self) {
-  VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
-  rb_iv_set(self, "@input", input);
-  return self;
-}
-
-/*
- * call-seq:
- *    sax_parser.callbacks -> #<XML::SaxParser::Callbacks subclass>
- * 
- * Obtain the callbacks used by this parser.
- */
-VALUE
-ruby_xml_sax_parser_callbacks_get(VALUE self) {
-  ruby_xml_sax_parser *rxsp;
-  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
-  return(rxsp->callbackHandler);
-}
-
-
-/*
- * call-seq:
- *    sax_parser.callbacks = #<XML::SaxParser::Callbacks subclass>
- * 
- * Set the callbacks used by this parser. The value assigned to
- * this attributesibute will usually be an object that extends the the 
- * XML::SaxParser::Callbacks module, overriding the callbacks it
- * wishes to process.
- */
-VALUE
-ruby_xml_sax_parser_callbacks_set(VALUE self, VALUE callbacks) {
-  ruby_xml_sax_parser *rxsp;
-  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
-  rxsp->callbackHandler = callbacks;
-  return(rxsp->callbackHandler);
-}
-
-/*
- * call-seq:
- *    parser.parse -> (true|false)
- * 
- * Parse the input XML, generating callbacks to the object
- * registered via the +callbacks+ attributesibute.
- */
-VALUE
-ruby_xml_sax_parser_parse(VALUE self) {
-  char *str;
-  int status = 1;
-  ruby_xml_sax_parser *rxsp;
-  VALUE source;
-  VALUE input = rb_ivar_get(self, INPUT_ATTR);
-
-  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
-
-  if (rb_ivar_get(input, FILE_ATTR) != Qnil)
-  {
-    source = rb_ivar_get(input, FILE_ATTR);
-    status = xmlSAXUserParseFile(rxsp->xsh, rxsp, StringValuePtr(source));
-  }
-  else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
-  {
-    source = rb_ivar_get(input, STRING_ATTR);
-    str = StringValueCStr(source);
-    status = xmlSAXUserParseMemory(rxsp->xsh, rxsp, str, strlen(str));
-  }
-  else
-  {
-    rb_raise(rb_eArgError, "You must specify a parser data source");
-  }
-  
-  if (status)
-  {
-    ruby_xml_raise(&xmlLastError);
-    return Qfalse;
-  }
-  else
-  {
-    return(Qtrue);
-  }
-}
-
-// Rdoc needs to know 
-#ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-void
-ruby_init_xml_sax_parser(void) {
-  /* SaxParser */
-  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
-  rb_define_alloc_func(cXMLSaxParser, ruby_xml_sax_parser_alloc);
-  rb_define_method(cXMLSaxParser, "callbacks", ruby_xml_sax_parser_callbacks_get, 0);
-  rb_define_method(cXMLSaxParser, "callbacks=", ruby_xml_sax_parser_callbacks_set, 1);
-  rb_define_method(cXMLSaxParser, "parse", ruby_xml_sax_parser_parse, 0);
-
-  /* Atributes */
-  rb_define_attr(cXMLSaxParser, "input", 1, 0);
-
-  /* Instance Methods */
-  rb_define_method(cXMLSaxParser, "initialize", ruby_xml_sax_parser_initialize, 0);
-
-
-  INPUT_ATTR = rb_intern("@input");
-
-  /* SaxCallbacks */
-  cbidOnInternalSubset = rb_intern("on_internal_subset");
-  cbidOnIsStandalone = rb_intern("on_is_standalone");
-  cbidOnHasInternalSubset = rb_intern("on_has_internal_subset");
-  cbidOnHasExternalSubset = rb_intern("on_has_external_subset");
-  cbidOnStartDocument = rb_intern("on_start_document");
-  cbidOnEndDocument = rb_intern("on_end_document");
-  cbidOnStartElement = rb_intern("on_start_element");
-  cbidOnEndElement = rb_intern("on_end_element");
-  cbidOnReference = rb_intern("on_reference");
-  cbidOnCharacters = rb_intern("on_characters");
-  cbidOnProcessingInstruction = rb_intern("on_processing_instruction");
-  cbidOnComment = rb_intern("on_comment");
-  cbidOnXmlParserWarning = rb_intern("on_parser_warning");
-  cbidOnXmlParserError = rb_intern("on_parser_error");
-  cbidOnXmlParserFatalError = rb_intern("on_parser_fatal_error");
-  cbidOnCdataBlock = rb_intern("on_cdata_block");
-  cbidOnExternalSubset = rb_intern("on_external_subset");
-}
+/* $Id: ruby_xml_sax_parser.c 616 2008-11-22 09:25:12Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_sax_parser.h"
+
+/*
+ * Document-class: LibXML::XML::SaxParser
+ *
+ * XML::SaxParser provides a callback based API for parsing documents,
+ * in contrast to XML::Parser's tree based API and XML::Reader's stream
+ * based API.  
+ *
+ * Note that the XML::SaxParser API is fairly complex, not well standardized, 
+ * and does not directly support validation making entity, namespace and
+ * base processing relatively hard.
+ *
+ * To use the XML::SaxParser, register a callback class via the
+ * XML::SaxParser#callbacks=.  It is easiest to include the 
+ * XML::SaxParser::Callbacks module in your class and override 
+ * the methods as needed.
+ *
+ * Basic example:
+ *
+ *   class MyCallbacks
+ *     include XML::SaxParser::Callbacks
+ *     def on_start_element(element, attributes)
+ *       puts #Element started: #{element}"
+ *     end
+ *   end
+ *
+ *   parser = XML::SaxParser.new
+ *   parser.callbacks = MyCallbacks.new
+ *   parser.parse
+ */
+
+VALUE cXMLSaxParser;
+VALUE mXMLSaxParserCallbacks;
+
+static ID INPUT_ATTR;
+static ID CALLBACKS_ATTR;
+
+VALUE cbidOnInternalSubset;
+VALUE cbidOnIsStandalone;
+VALUE cbidOnHasInternalSubset;
+VALUE cbidOnHasExternalSubset;
+VALUE cbidOnStartDocument;
+VALUE cbidOnEndDocument;
+VALUE cbidOnStartElement;
+VALUE cbidOnEndElement;
+VALUE cbidOnReference;
+VALUE cbidOnCharacters;
+VALUE cbidOnProcessingInstruction;
+VALUE cbidOnComment;
+VALUE cbidOnXmlParserWarning;
+VALUE cbidOnXmlParserError;
+VALUE cbidOnXmlParserFatalError;
+VALUE cbidOnCdataBlock;
+VALUE cbidOnExternalSubset;
+
+#include "sax_parser_callbacks.inc"
+
+/*
+ * call-seq:
+ *    sax_parser.initialize -> sax_parser
+ * 
+ * Initiliazes instance of parser.
+ */
+static VALUE
+rxml_sax_parser_initialize(VALUE self) {
+  VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
+  rb_iv_set(self, "@input", input);
+  return self;
+}
+
+
+/* Parsing data sources */
+static int
+rxml_sax_parser_parse_file(VALUE self, VALUE input) {
+  VALUE file = rb_ivar_get(input, FILE_ATTR);
+  return xmlSAXUserParseFile(&rxml_sax_hander_struct, self, StringValuePtr(file));
+}
+
+static int
+rxml_sax_parser_parse_string(VALUE self, VALUE input) {
+  VALUE str = rb_ivar_get(input, STRING_ATTR);
+  return xmlSAXUserParseMemory(&rxml_sax_hander_struct, self, StringValuePtr(str), RSTRING_LEN(str));
+}
+
+static int
+rxml_sax_parser_parse_io(VALUE self, VALUE input) {
+  VALUE io = rb_ivar_get(input, IO_ATTR);
+  VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
+  xmlCharEncoding xmlEncoding = NUM2INT(encoding);
+  xmlParserCtxtPtr ctxt = xmlCreateIOParserCtxt(&rxml_sax_hander_struct, self,
+	 			                                        (xmlInputReadCallback) rxml_read_callback,
+				                                         NULL, io, xmlEncoding);
+  return xmlParseDocument(ctxt);
+}
+
+
+/*
+ * call-seq:
+ *    parser.parse -> (true|false)
+ * 
+ * Parse the input XML, generating callbacks to the object
+ * registered via the +callbacks+ attributesibute.
+ */
+static VALUE
+rxml_sax_parser_parse(VALUE self) {
+  int status;
+  VALUE input = rb_ivar_get(self, INPUT_ATTR);
+  
+  if (rb_ivar_get(input, FILE_ATTR) != Qnil)
+    status = rxml_sax_parser_parse_file(self, input);
+  else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
+    status = rxml_sax_parser_parse_string(self, input);
+  else if (rb_ivar_get(input, IO_ATTR) != Qnil)
+    status = rxml_sax_parser_parse_io(self, input);
+  else
+    rb_raise(rb_eArgError, "You must specify a parser data source");
+  
+  if (status)
+  {
+    rxml_raise(&xmlLastError);
+    return Qfalse;
+  }
+  else
+  {
+    return(Qtrue);
+  }
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXML = rb_define_module_under(mLibXML, "XML");
+#endif
+
+void
+ruby_init_xml_sax_parser(void) {
+  /* SaxParser */
+  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
+
+  /* Atributes */
+  CALLBACKS_ATTR = rb_intern("@callbacks");
+  INPUT_ATTR = rb_intern("@input");
+  rb_define_attr(cXMLSaxParser, "callbacks", 1, 1);
+  rb_define_attr(cXMLSaxParser, "input", 1, 0);
+
+  /* Instance Methods */
+  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, 0);
+  rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
+
+  /* SaxCallbacks */
+  cbidOnInternalSubset = rb_intern("on_internal_subset");
+  cbidOnIsStandalone = rb_intern("on_is_standalone");
+  cbidOnHasInternalSubset = rb_intern("on_has_internal_subset");
+  cbidOnHasExternalSubset = rb_intern("on_has_external_subset");
+  cbidOnStartDocument = rb_intern("on_start_document");
+  cbidOnEndDocument = rb_intern("on_end_document");
+  cbidOnStartElement = rb_intern("on_start_element");
+  cbidOnEndElement = rb_intern("on_end_element");
+  cbidOnReference = rb_intern("on_reference");
+  cbidOnCharacters = rb_intern("on_characters");
+  cbidOnProcessingInstruction = rb_intern("on_processing_instruction");
+  cbidOnComment = rb_intern("on_comment");
+  cbidOnXmlParserWarning = rb_intern("on_parser_warning");
+  cbidOnXmlParserError = rb_intern("on_parser_error");
+  cbidOnXmlParserFatalError = rb_intern("on_parser_fatal_error");
+  cbidOnCdataBlock = rb_intern("on_cdata_block");
+  cbidOnExternalSubset = rb_intern("on_external_subset");
+}