libxml-ruby 0.3.8.4 → 0.5.0

data/ext/xml/ruby_xml_reader.h

@@ -0,0 +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__
+
+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);
+
+#endif /* __RUBY_XML_READER__ */

data/ext/xml/ruby_xml_sax_parser.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_sax_parser.c,v 1.6 2006/08/15 13:53:45 roscopeco Exp $ */
+/* $Id: ruby_xml_sax_parser.c 111 2006-11-20 01:39:14Z roscopeco $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -6,7 +6,25 @@
 #include "ruby_xml_sax_parser.h"
 
 VALUE cXMLSaxParser;
-VALUE callsym;
+VALUE mXMLSaxParserCallbacks;
+
+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"
 
@@ -17,39 +35,21 @@ 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);
+  if (rxsp->callbackHandler && (rxsp->callbackHandler != Qnil)) {
+    rb_gc_mark(rxsp->callbackHandler);
+  }
   
   if (rxsp->filename && (rxsp->filename != Qnil)) {
-    rb_gc_mark(rxsp->filename);    
+    rb_gc_mark(rxsp->filename);
   }
-  
+
   if (rxsp->str && (rxsp->str != Qnil)) {
-    rb_gc_mark(rxsp->str);    
+    rb_gc_mark(rxsp->str);
   }
 }
 
-
 /*
  * call-seq:
  *    XML::SaxParser.new => sax_parser
@@ -61,10 +61,9 @@ ruby_xml_sax_parser_new(VALUE class) {
   ruby_xml_sax_parser *rxsp;
   
   rxsp = ALLOC(ruby_xml_sax_parser);
-  rxsp->cbp = ALLOC(ruby_xml_sax_parser_callbacks);
-  memset(rxsp->cbp, 0, sizeof(ruby_xml_sax_parser_callbacks));
   rxsp->xsh = &rubySAXHandlerStruct;
-  
+
+  rxsp->callbackHandler = Qnil;  
   rxsp->xpc = NULL;
   rxsp->filename = Qnil;
   rxsp->str = Qnil;
@@ -74,6 +73,38 @@ ruby_xml_sax_parser_new(VALUE class) {
 }
 
 
+/*
+ * 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 attribute 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:
  *    sax_parser.filename => "filename"
@@ -103,280 +134,276 @@ ruby_xml_sax_parser_filename_set(VALUE self, VALUE filename) {
   return(rxsp->filename);
 }
 
-#define set_handler(self, argc, argv, handler)      \
-  VALUE proc;                                       \
-  ruby_xml_sax_parser *rxsp;                        \
-  rb_scan_args(argc, argv, "0&", &proc);            \
-  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp); \
-  rxsp->cbp->handler = proc;                        \
-  return(Qnil);
+ 
+/*
+ * call-seq:
+ *    parser.parse => (true|false)
+ * 
+ * Parse the input XML, generating callbacks to the object
+ * registered via the +callbacks+ attribute.
+ */
+VALUE
+ruby_xml_sax_parser_parse(VALUE self) {
+  char *str;
+  int status = 1;
+  ruby_xml_sax_parser *rxsp;
+
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+
+  if (rxsp->filename != Qnil) {
+    status = xmlSAXUserParseFile(rxsp->xsh, rxsp, StringValuePtr(rxsp->filename));
+  } else if (rxsp->str != Qnil) {
+    str = StringValuePtr(rxsp->str);
+    status = //ruby_xml_document_new(cXMLDocument,
+				   xmlSAXUserParseMemory(rxsp->xsh, rxsp,
+                 str, strlen(str)); //);
+  }
+  
+  /* 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);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string => "xml"
+ * 
+ * Obtain the parser's input string.
+ */
+VALUE
+ruby_xml_sax_parser_str_get(VALUE self) {
+  ruby_xml_sax_parser *rxsp;
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  return(rxsp->str);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string = "xml"
+ * 
+ * Set the parser's input string.
+ */
+VALUE
+ruby_xml_sax_parser_str_set(VALUE self, VALUE str) {
+  ruby_xml_sax_parser *rxsp;
+  Check_Type(str, T_STRING);
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  rxsp->str = str;
+  return(rxsp->str);
+}
+
 
+/****** SaxCallbacks ******/
+/* These are all the same. Bloody Rdoc... */
 
 /*
  * call-seq:
- *    parser.on_internal_subset { |name, external_id, system_id| ... } => nil
+ *    callbacks.on_internal_subset(name, external_id, system_id)
  *
- * Set the callback block for an internal subset event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_internal_subset(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_is_standalone { || ... } => nil
+ *    callbacks.on_is_standalone()
  *
- * Set the callback proc for 'is standalone' event.
+ * Called for 'is standalone' event.
  */
 VALUE
-ruby_xml_sax_parser_on_is_standalone(int argc, VALUE *argv, VALUE self) {
-  set_handler(self, argc, argv, isStandalone);
+ruby_xml_sax_callbacks_on_is_standalone(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_has_internal_subset { || ... } => nil
+ *    callbacks.on_has_internal_subset()
  *
- * Set the callback proc for an internal subset notification event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_has_internal_subset(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_has_external_subset { || ... } => nil
+ *    callbacks.on_has_external_subset()
  *
- * Set the callback proc for an external subset notification event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_has_external_subset(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_start_document { || ... } => nil
+ *    callbacks.on_start_document()
  *
- * Set the callback proc for a start document event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_start_document(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_end_document { || ... } => nil
+ *    callbacks.on_end_document()
  *
- * Set the callback proc for an end document event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_end_document(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_start_element { |name, attr_hash| ... } => nil
+ *    callbacks.on_start_element(name, attr_hash)
  * 
- * Set the callback proc for an element start event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_start_element(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_end_element { |name| ... } => nil
+ *    callbacks.on_end_element(name)
  *
- * Set the callback proc for an element end event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_end_element(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_reference { |name| ... } => nil
+ *    callbacks.on_reference(name)
  *
- * Set the callback proc for a reference event.
+ * Called for a reference event.
  */
 VALUE
-ruby_xml_sax_parser_on_reference(int argc, VALUE *argv, VALUE self) {
-  set_handler(self, argc, argv, reference);
+ruby_xml_sax_callbacks_on_reference(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_characters { |chars| ... } => nil
+ *    callbacks.on_characters(chars)
  *
- * Set the callback proc for a characters event.
+ * Called for a characters event.
  */
 VALUE
-ruby_xml_sax_parser_on_characters(int argc, VALUE *argv, VALUE self) {
-  set_handler(self, argc, argv, characters);
+ruby_xml_sax_callbacks_on_characters(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_processing_instruction { |target, data| ... } => nil
+ *    callbacks.on_processing_instruction(target, data)
  *
- * Set the callback proc for an processing instruction event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_processing_instruction(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_comment { |msg| ... } => nil
+ *    callbacks.on_comment(msg)
  *
- * Set the callback proc for a comment event.
+ * Called for a comment event.
  */
 VALUE
-ruby_xml_sax_parser_on_comment(int argc, VALUE *argv, VALUE self) {
-  set_handler(self, argc, argv, comment);
+ruby_xml_sax_callbacks_on_comment(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
 
 
 /*
  * call-seq:
- *    parser.on_parser_warning { |msg| ... } => nil
+ *    callbacks.on_parser_warning(msg)
  *
- * Set the callback proc that receives parser warnings.
+ * Called for parser warnings.
  */
 VALUE
-ruby_xml_sax_parser_on_parser_warning(int argc, VALUE *argv, VALUE self) {
-  set_handler(self, argc, argv, xmlParserWarning);
+ruby_xml_sax_callbacks_on_parser_warning(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
  
 /*
  * call-seq:
- *    parser.on_parser_error { |msg| ... } => nil
+ *    callbacks.on_parser_error(msg)
  *
- * Set the callback proc that receives parser errors.
+ * Called for parser errors.
  */
 VALUE
-ruby_xml_sax_parser_on_parser_error(int argc, VALUE *argv, VALUE self) {
-  set_handler(self, argc, argv, xmlParserError);
+ruby_xml_sax_callbacks_on_parser_error(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
   
 /*
  * call-seq:
- *    parser.on_parser_fatal_error { |msg| ... } => nil
+ *    callbacks.on_parser_fatal_error(msg)
  *
- * Set the callback proc that receives fatal parser errors.
+ * Called for fatal parser errors.
  */
 VALUE
-ruby_xml_sax_parser_on_parser_fatal_error(int argc, VALUE *argv, VALUE self) {
-  set_handler(self, argc, argv, xmlParserFatalError);
+ruby_xml_sax_callbacks_on_parser_fatal_error(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
 /*
  * call-seq:
- *    parser.on_cdata_block { |cdata| ... } => nil
+ *    callbacks.on_cdata_block(cdata)
  *
- * Set the callback proc for a CDATA block event.
+ * Called 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);
+ruby_xml_sax_callbacks_on_cdata_block(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
  
 /*
  * call-seq:
- *    parser.on_external_subset { |name, external_id, system_id| ... } => nil
+ *    callbacks.on_external_subset(name, external_id, system_id)
  *
- * 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, 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 = 1;
-  ruby_xml_sax_parser *rxsp;
-
-  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
-
-  if (rxsp->filename != Qnil) {
-    status = xmlSAXUserParseFile(rxsp->xsh, rxsp->cbp, StringValuePtr(rxsp->filename));
-  } else if (rxsp->str != Qnil) {
-    str = StringValuePtr(rxsp->str);
-    status = //ruby_xml_document_new(cXMLDocument,
-				   xmlSAXUserParseMemory(rxsp->xsh, rxsp->cbp,
-                 str, strlen(str)); //);
-  }
-  
-  /* 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);
-}
-
-
-/*
- * call-seq:
- *    parser.string => "xml"
- * 
- * Obtain the parser's input string.
+ * Called for an external subset event.
  */
 VALUE
-ruby_xml_sax_parser_str_get(VALUE self) {
-  ruby_xml_sax_parser *rxsp;
-  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
-  return(rxsp->str);
+ruby_xml_sax_callbacks_on_external_subset(int argc, VALUE *argv, VALUE self) {
+  return Qnil;
 }
 
 
-/*
- * call-seq:
- *    parser.string = "xml"
- * 
- * Set the parser's input string.
- */
-VALUE
-ruby_xml_sax_parser_str_set(VALUE self, VALUE str) {
-  ruby_xml_sax_parser *rxsp;
-  Check_Type(str, T_STRING);
-  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
-  rxsp->str = str;
-  return(rxsp->str);
-}
-
 // Rdoc needs to know 
 #ifdef RDOC_NEVER_DEFINED
   mXML = rb_define_module("XML");
@@ -385,50 +412,74 @@ 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");
+  mXMLSaxParserCallbacks = rb_define_module_under(cXMLSaxParser, "Callbacks");
 
+  /* SaxParser */
   rb_define_singleton_method(cXMLSaxParser, "new", ruby_xml_sax_parser_new, 0);
 
   rb_define_method(cXMLSaxParser, "filename",
-		   ruby_xml_sax_parser_filename_get, 0);
+       ruby_xml_sax_parser_filename_get, 0);
   rb_define_method(cXMLSaxParser, "filename=",
-		   ruby_xml_sax_parser_filename_set, 1);
+       ruby_xml_sax_parser_filename_set, 1);
+  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);
   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);              
+  /* 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");
+
+  rb_define_method(mXMLSaxParserCallbacks, "on_internal_subset", 
+      ruby_xml_sax_callbacks_on_internal_subset, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_is_standalone", 
+      ruby_xml_sax_callbacks_on_is_standalone, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_has_internal_subset", 
+      ruby_xml_sax_callbacks_on_has_internal_subset, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_has_external_subset", 
+      ruby_xml_sax_callbacks_on_has_external_subset, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_start_document", 
+      ruby_xml_sax_callbacks_on_start_document, -1);  
+  rb_define_method(mXMLSaxParserCallbacks, "on_end_document", 
+      ruby_xml_sax_callbacks_on_end_document, -1);  
+  rb_define_method(mXMLSaxParserCallbacks, "on_start_element", 
+      ruby_xml_sax_callbacks_on_start_element, -1);  
+  rb_define_method(mXMLSaxParserCallbacks, "on_end_element", 
+      ruby_xml_sax_callbacks_on_end_element, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_reference", 
+      ruby_xml_sax_callbacks_on_reference, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_characters", 
+      ruby_xml_sax_callbacks_on_characters, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_processing_instruction", 
+      ruby_xml_sax_callbacks_on_processing_instruction, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_comment", 
+      ruby_xml_sax_callbacks_on_comment, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_parser_warning", 
+      ruby_xml_sax_callbacks_on_parser_warning, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_parser_error", 
+      ruby_xml_sax_callbacks_on_parser_error, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_parser_fatal_error", 
+      ruby_xml_sax_callbacks_on_parser_fatal_error, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_cdata_block", 
+      ruby_xml_sax_callbacks_on_cdata_block, -1);        
+  rb_define_method(mXMLSaxParserCallbacks, "on_external_subset", 
+      ruby_xml_sax_callbacks_on_external_subset, -1);              
 }