libxml-ruby 0.3.6 → 0.3.8

data/ext/xml/ruby_xml_node_set.c

@@ -1,10 +1,15 @@
-/* $Id: ruby_xml_node_set.c,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+/* $Id: ruby_xml_node_set.c,v 1.3 2006/04/14 14:45:25 roscopeco Exp $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
 #include "libxml.h"
 #include "ruby_xml_node_set.h"
 
+/*
+ * Document-class: XML::Node::Set
+ * 
+ * Includes Enumerable.
+ */
 VALUE cXMLNodeSet;
 
 // TODO maybe we should support [] on nodeset?
@@ -24,14 +29,14 @@ ruby_xml_node_set_to_a(VALUE self) {
 
   Data_Get_Struct(self, ruby_xml_node_set, rxnset);
 
-  if ((rxnset->node_set == NULL) || (rxnset->node_set->nodeNr == 0))
-    return(Qnil);
-
   set_ary = rb_ary_new();
-  for (i = 0; i < rxnset->node_set->nodeNr; i++) {
-    nodeobj = ruby_xml_node_new2(cXMLNode, rxnset->xd, rxnset->node_set->nodeTab[i]);
-    rb_ary_push(set_ary, nodeobj);
+  if (!((rxnset->node_set == NULL) || (rxnset->node_set->nodeNr == 0))) {
+    for (i = 0; i < rxnset->node_set->nodeNr; i++) {
+      nodeobj = ruby_xml_node_new2(cXMLNode, rxnset->xd, rxnset->node_set->nodeTab[i]);
+      rb_ary_push(set_ary, nodeobj);
+    }
   }
+  
   return(set_ary);
 }
 
@@ -68,6 +73,48 @@ ruby_xml_node_set_each(VALUE self) {
 }
 
 
+/*
+ * call-seq:
+ *    nodeset.empty? => (true|false)
+ *
+ * Determine whether this nodeset is empty (contains no nodes).
+ */
+VALUE
+ruby_xml_node_set_empty_q(VALUE self) {
+  ruby_xml_node_set *rxnset;
+    Data_Get_Struct(self, ruby_xml_node_set, rxnset);
+  return ( rxnset->node_set == NULL || rxnset->node_set->nodeNr <= 0 ) ? Qtrue : Qfalse;
+}
+
+
+/*
+ * call-seq:
+ *    nodeset.first => node
+ *
+ * Returns the first node in this node set, or nil if none exist.
+ */
+VALUE
+ruby_xml_node_set_first(VALUE self) {
+  ruby_xml_node_set *rxnset; 
+  VALUE nodeobj;
+
+  Data_Get_Struct(self, ruby_xml_node_set, rxnset);
+  
+  if (rxnset->node_set == NULL || rxnset->node_set->nodeNr < 1)
+    return(Qnil);
+    
+  switch(rxnset->node_set->nodeTab[0]->type) {
+    case XML_ATTRIBUTE_NODE:
+      nodeobj = ruby_xml_attr_new2(cXMLAttr, rxnset->xd, (xmlAttrPtr)rxnset->node_set->nodeTab[0]);
+      break;
+    default:
+      nodeobj = ruby_xml_node_new2(cXMLNode, rxnset->xd, rxnset->node_set->nodeTab[0]);
+  }
+
+  return(nodeobj);
+}
+
+
 void
 ruby_xml_node_set_free(ruby_xml_node_set *rxnset) {
   void *data;
@@ -108,7 +155,7 @@ ruby_xml_node_set_length(VALUE self) {
     return(INT2NUM(rxnset->node_set->nodeNr));
 }
 
-// TODO Check this for doublefree (should we mark nodes?)
+
 static void
 ruby_xml_node_set_mark(ruby_xml_node_set *rxnset) {
   if (rxnset == NULL) return;
@@ -186,12 +233,16 @@ ruby_xml_node_set_xpath_data_get(VALUE self) {
 
 void
 ruby_init_xml_node_set(void) {
-  cXMLNodeSet = rb_define_class_under(cXMLNode, "Set", rb_cObject);
+  cXMLNodeSet = rb_define_class_under(cXMLNode, "Set", rb_cObject);  
+  rb_include_module(cXMLNodeSet, rb_const_get(rb_cObject, rb_intern("Enumerable")));
 
-  rb_define_method(cXMLNodeSet, "to_a", ruby_xml_node_set_to_a, 0);
   rb_define_method(cXMLNodeSet, "each", ruby_xml_node_set_each, 0);
+  rb_define_method(cXMLNodeSet, "empty?", ruby_xml_node_set_empty_q, 0);
+  rb_define_method(cXMLNodeSet, "first", ruby_xml_node_set_first, 0);
   rb_define_method(cXMLNodeSet, "length", ruby_xml_node_set_length, 0);
+  rb_define_method(cXMLNodeSet, "to_a", ruby_xml_node_set_to_a, 0);
   rb_define_method(cXMLNodeSet, "xpath", ruby_xml_node_set_xpath_get, 0);
   rb_define_method(cXMLNodeSet, "xpath_ctxt",
 		   ruby_xml_node_set_xpath_data_get, 0);
+       
 }

data/ext/xml/ruby_xml_parser.c

@@ -1,9 +1,12 @@
-/* $Id: ruby_xml_parser.c,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+/* $Id: ruby_xml_parser.c,v 1.3 2006/03/27 20:49:19 roscopeco Exp $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
 #include "libxml.h"
 
+static VALUE libxml_xmlRubyErrorProc = Qnil;
+static int id_call;
+
 int ruby_xml_parser_count = 0;
 VALUE cXMLParser;
 VALUE eXMLParserParseError;
@@ -218,7 +221,7 @@ ruby_xml_parser_enabled_memory_debug_location_q(VALUE class) {
 
 /*
  * call-seq:
- * 		XML::Parser.enabled_catalog? => (true|false)  
+ * 		XML::Parser.enabled_regexp? => (true|false)  
  * 
  * Determine whether libxml regular expression support is enabled.
  */
@@ -267,7 +270,7 @@ ruby_xml_parser_enabled_thread_q(VALUE class) {
 
 /*
  * call-seq:
- * 		XML::Parser.enabled_catalog? => (true|false)  
+ * 		XML::Parser.enabled_unicode? => (true|false)  
  * 
  * Determine whether libxml unicode support is enabled.
  */
@@ -283,7 +286,7 @@ ruby_xml_parser_enabled_unicode_q(VALUE class) {
 
 /*
  * call-seq:
- * 		XML::Parser.enabled_catalog? => (true|false)  
+ * 		XML::Parser.enabled_xinclude? => (true|false)  
  * 
  * Determine whether libxml xinclude support is enabled.
  */
@@ -299,7 +302,7 @@ ruby_xml_parser_enabled_xinclude_q(VALUE class) {
 
 /*
  * call-seq:
- * 		XML::Parser.enabled_catalog? => (true|false)  
+ * 		XML::Parser.enabled_xpath? => (true|false)  
  * 
  * Determine whether libxml xpath support is enabled.
  */
@@ -315,7 +318,7 @@ ruby_xml_parser_enabled_xpath_q(VALUE class) {
 
 /*
  * call-seq:
- * 		XML::Parser.enabled_catalog? => (true|false)  
+ * 		XML::Parser.enabled_xpointer? => (true|false)  
  * 
  * Determine whether libxml xpointer support is enabled.
  */
@@ -331,7 +334,7 @@ ruby_xml_parser_enabled_xpointer_q(VALUE class) {
 
 /*
  * call-seq:
- * 		XML::Parser.enabled_catalog? => (true|false)  
+ * 		XML::Parser.enabled_zlib? => (true|false)  
  * 
  * Determine whether libxml zlib support is enabled.
  */
@@ -1216,6 +1219,52 @@ ruby_xml_parser_str_set(VALUE self, VALUE str) {
   return(data->str);
 }
 
+/*
+ * call-seq:
+ *    XML::Parser.register_error_handler(lambda { |msg| ... }) => old_handler
+ *    XML::Parser.register_error_handler(nil) => old_handler
+ * 
+ * Register the attached block as the handler for parser errors.
+ * A message describing parse errors is passed to the block.
+ * Libxml passes error messages to the handler in parts, one per call.
+ * A typical error results in six calls to this proc, with arguments:
+ * 
+ *   "Entity: line 1: ", 
+ *   "parser ", 
+ *   "error : ", 
+ *   "Opening and ending tag mismatch: foo line 1 and foz\n",
+ *   "<foo><bar/></foz>\n",
+ *   "                 ^\n"
+ * 
+ * Note that the error handler is shared by all threads.
+ */
+VALUE
+ruby_xml_parser_registerErrorHandler(VALUE self, VALUE proc) {
+  VALUE old_block = libxml_xmlRubyErrorProc;
+  libxml_xmlRubyErrorProc = proc;
+  return(old_block);
+}
+
+static void
+libxml_xmlErrorFuncHandler(ATTRIBUTE_UNUSED void *ctx, const char *msg, ...)
+{
+  va_list ap;
+  char str[1000];
+  VALUE rstr;
+
+  if (libxml_xmlRubyErrorProc == Qnil) {
+    va_start(ap, msg);
+    vfprintf(stderr, msg, ap);
+    va_end(ap);
+  } else {
+    va_start(ap, msg);
+    if (vsnprintf(str, 999, msg, ap) >= 998) str[999] = 0;
+    va_end(ap);
+
+    rstr = rb_str_new2(str);
+    rb_funcall2(libxml_xmlRubyErrorProc, id_call, 1, &rstr);
+  }
+}
 
 /* #define RUBY_XML_PARSER_ENABLED_INIT(func, method) \
  rb_define_singleton_method(cXMLParser, method, \
@@ -1351,7 +1400,7 @@ ruby_init_parser(void) {
 			     ruby_xml_parser_memory_used, 0);
   rb_define_singleton_method(cXMLParser, "new", ruby_xml_parser_new, 0);
   rb_define_singleton_method(cXMLParser, "string", ruby_xml_parser_new_string, 1);
-
+  rb_define_singleton_method(cXMLParser, "register_error_handler", ruby_xml_parser_registerErrorHandler, 1);
   rb_define_method(cXMLParser, "filename", ruby_xml_parser_filename_get, 0);
   rb_define_method(cXMLParser, "filename=", ruby_xml_parser_filename_set, 1);
   rb_define_method(cXMLParser, "io", ruby_xml_parser_io_get, 0);
@@ -1360,4 +1409,9 @@ ruby_init_parser(void) {
   rb_define_method(cXMLParser, "parser_context", ruby_xml_parser_parser_context_get, 0);
   rb_define_method(cXMLParser, "string", ruby_xml_parser_str_get, 0);
   rb_define_method(cXMLParser, "string=", ruby_xml_parser_str_set, 1);
+  
+  // set up error handling
+  xmlSetGenericErrorFunc(NULL, libxml_xmlErrorFuncHandler);
+  xmlThrDefSetGenericErrorFunc(NULL, libxml_xmlErrorFuncHandler);
+  id_call = rb_intern("call");
 }

data/ext/xml/ruby_xml_sax_parser.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_sax_parser.c,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+/* $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 */
 
@@ -6,6 +6,9 @@
 #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) {
@@ -14,6 +17,31 @@ ruby_xml_sax_parser_free(ruby_xml_sax_parser *rxsp) {
   /* 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
@@ -23,46 +51,18 @@ ruby_xml_sax_parser_free(ruby_xml_sax_parser *rxsp) {
 VALUE
 ruby_xml_sax_parser_new(VALUE class) {
   ruby_xml_sax_parser *rxsp;
-
-  xmlSAXHandler emptySAXHandlerStruct = {
-    NULL, /* internalSubset */
-    NULL, /* isStandalone */
-    NULL, /* hasInternalSubset */
-    NULL, /* hasExternalSubset */
-    NULL, /* resolveEntity */
-    NULL, /* getEntity */
-    NULL, /* entityDecl */
-    NULL, /* notationDecl */
-    NULL, /* attributeDecl */
-    NULL, /* elementDecl */
-    NULL, /* unparsedEntityDecl */
-    NULL, /* setDocumentLocator */
-    NULL, /* startDocument */
-    NULL, /* endDocument */
-    NULL, /* startElement */
-    NULL, /* endElement */
-    NULL, /* reference */
-    NULL, /* characters */
-    NULL, /* ignorableWhitespace */
-    NULL, /* processingInstruction */
-    NULL, /* comment */
-    NULL, /* xmlParserWarning */
-    NULL, /* xmlParserError */
-    NULL, /* xmlParserError */
-    NULL, /* getParameterEntity */
-    NULL, /* cdataBlock; */
-    NULL, /* externalSubset; */
-    1
-  };
-
+  
   rxsp = ALLOC(ruby_xml_sax_parser);
-  rxsp->xsh = &emptySAXHandlerStruct;
-
+  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, 0, ruby_xml_sax_parser_free, rxsp));
+  return(Data_Wrap_Struct(class, ruby_xml_sax_parser_mark, 
+                              ruby_xml_sax_parser_free, rxsp));
 }
 
 
@@ -95,39 +95,248 @@ ruby_xml_sax_parser_filename_set(VALUE self, VALUE 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.parse => document
+ *    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.
+ * 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;
+  int status = 1;
   ruby_xml_sax_parser *rxsp;
-  VALUE docobj = Qnil;
 
   Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
 
   if (rxsp->filename != Qnil) {
-    status = xmlSAXUserParseFile(rxsp->xsh, NULL, StringValuePtr(rxsp->filename));
-
-    /* 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)
-      docobj = Qfalse;
-    else
-      docobj = Qtrue;
+    status = xmlSAXUserParseFile(rxsp->xsh, rxsp->cbp, StringValuePtr(rxsp->filename));
   } else if (rxsp->str != Qnil) {
     str = StringValuePtr(rxsp->str);
-    docobj = ruby_xml_document_new(cXMLDocument,
-				   xmlSAXParseMemory(rxsp->xsh, str,
-						     strlen(str), 0));
+    status = //ruby_xml_document_new(cXMLDocument,
+				   xmlSAXUserParseMemory(rxsp->xsh, rxsp->cbp,
+                 str, strlen(str)); //);
   }
-  return(docobj);
+  
+  /* 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);
 }
 
 
@@ -168,6 +377,7 @@ ruby_xml_sax_parser_str_set(VALUE self, VALUE str) {
 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);
 
@@ -178,4 +388,39 @@ ruby_init_xml_sax_parser(void) {
   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);              
 }