libxml-ruby 3.2.2-x64-mingw-ucrt

data/ext/libxml/ruby_xml_error.h

@@ -0,0 +1,12 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_ERROR__
+#define __RXML_ERROR__
+
+extern VALUE eXMLError;
+
+void rxml_init_error();
+VALUE rxml_error_wrap(xmlErrorPtr xerror);
+NORETURN(void rxml_raise(xmlErrorPtr xerror));
+
+#endif

data/ext/libxml/ruby_xml_html_parser.c

@@ -0,0 +1,89 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+
+/* 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.
+ *
+ * The HTML parser creates an in-memory document object
+ * that consist of any number of XML::Node instances.  This is simple
+ * and powerful model, but has the major limitation that the size of
+ * the document that can be processed is limited by the amount of
+ * memory available.
+ *
+ * Using the html parser is simple:
+ *
+ *   parser = XML::HTMLParser.file('my_file')
+ *   doc = parser.parse
+ *
+ * You can also parse documents (see XML::HTMLParser.document), 
+ * strings (see XML::HTMLParser.string) and io objects (see
+ * XML::HTMLParser.io).
+ */
+
+VALUE cXMLHtmlParser;
+static ID CONTEXT_ATTR;
+
+
+/* call-seq:
+ *    XML::HTMLParser.initialize -> parser
+ *
+ * Initializes a new parser instance with no pre-determined source.
+ */
+static VALUE rxml_html_parser_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE context = Qnil;
+
+  rb_scan_args(argc, argv, "01", &context);
+
+  if (context == Qnil)
+  {
+    rb_raise(rb_eArgError, "An instance of a XML::Parser::Context must be passed to XML::HTMLParser.new");
+  }
+
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    parser.parse -> XML::Document
+ *
+ * Parse the input XML and create an XML::Document with
+ * it's content. If an error occurs, XML::Parser::ParseError
+ * is thrown.
+ */
+static VALUE rxml_html_parser_parse(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  
+  Data_Get_Struct(context, xmlParserCtxt, ctxt);
+
+  if (htmlParseDocument(ctxt) == -1 && ! ctxt->recovery)
+  {
+    rxml_raise(&ctxt->lastError);
+  }
+
+  rb_funcall(context, rb_intern("close"), 0);
+
+  return rxml_document_wrap(ctxt->myDoc);
+}
+
+void rxml_init_html_parser(void)
+{
+  CONTEXT_ATTR = rb_intern("@context");
+
+  cXMLHtmlParser = rb_define_class_under(mXML, "HTMLParser", rb_cObject);
+
+  /* Atributes */
+  rb_define_attr(cXMLHtmlParser, "input", 1, 0);
+
+  /* Instance methods */
+  rb_define_method(cXMLHtmlParser, "initialize", rxml_html_parser_initialize, -1);
+  rb_define_method(cXMLHtmlParser, "parse", rxml_html_parser_parse, 0);
+}

data/ext/libxml/ruby_xml_html_parser.h

@@ -0,0 +1,10 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_HTML_PARSER__
+#define __RXML_HTML_PARSER__
+
+extern VALUE cXMLHtmlParser;
+
+void rxml_init_html_parser(void);
+
+#endif

data/ext/libxml/ruby_xml_html_parser_context.c

@@ -0,0 +1,337 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_html_parser_context.h"
+
+
+/*
+ * Document-class: LibXML::XML::HTMLParser::Context
+ *
+ * The XML::HTMLParser::Context class provides in-depth control over how
+ * a document is parsed.
+ */
+
+VALUE cXMLHtmlParserContext;
+static ID IO_ATTR;
+
+/* OS X 10.5 ships with libxml2 version 2.6.16 which does not expose the
+   htmlNewParserCtxt (or htmlInitParserCtxt which it uses) method.  htmlNewParserCtxt
+   wasn't added to the libxml2 header files until 2.6.27.  So the next two 
+   methods are simply copied from a newer version of libxml2 (2.7.2). */
+#if LIBXML_VERSION < 20627
+#define XML_CTXT_FINISH_DTD_0 0xabcd1234
+static int htmlInitParserCtxt(htmlParserCtxtPtr ctxt)
+{
+  htmlSAXHandler *sax;
+  if (ctxt == NULL) return(-1);
+  
+  memset(ctxt, 0, sizeof(htmlParserCtxt));
+  ctxt->dict = xmlDictCreate();
+  if (ctxt->dict == NULL) {
+    rb_raise(rb_eNoMemError, "htmlInitParserCtxt: out of memory\n");
+    return(-1);
+  }
+  sax = (htmlSAXHandler *) xmlMalloc(sizeof(htmlSAXHandler));
+  if (sax == NULL) {
+    rb_raise(rb_eNoMemError, "htmlInitParserCtxt: out of memory\n");
+    return(-1);
+  }
+  else
+    memset(sax, 0, sizeof(htmlSAXHandler));
+
+  ctxt->inputTab = (htmlParserInputPtr *) xmlMalloc(5 * sizeof(htmlParserInputPtr));
+  if (ctxt->inputTab == NULL) {
+    rb_raise(rb_eNoMemError, "htmlInitParserCtxt: out of memory\n");
+    ctxt->inputNr = 0;
+    ctxt->inputMax = 0;
+    ctxt->input = NULL;
+    return(-1);
+  }
+  ctxt->inputNr = 0;
+  ctxt->inputMax = 5;
+  ctxt->input = NULL;
+  ctxt->version = NULL;
+  ctxt->encoding = NULL;
+  ctxt->standalone = -1;
+  ctxt->instate = XML_PARSER_START;
+
+  ctxt->nodeTab = (htmlNodePtr *) xmlMalloc(10 * sizeof(htmlNodePtr));
+  if (ctxt->nodeTab == NULL) {
+    rb_raise(rb_eNoMemError, "htmlInitParserCtxt: out of memory\n");
+    ctxt->nodeNr = 0;
+    ctxt->nodeMax = 0;
+    ctxt->node = NULL;
+    ctxt->inputNr = 0;
+    ctxt->inputMax = 0;
+    ctxt->input = NULL;
+    return(-1);
+  }
+  ctxt->nodeNr = 0;
+  ctxt->nodeMax = 10;
+  ctxt->node = NULL;
+
+  ctxt->nameTab = (const xmlChar **) xmlMalloc(10 * sizeof(xmlChar *));
+  if (ctxt->nameTab == NULL) {
+    rb_raise(rb_eNoMemError, "htmlInitParserCtxt: out of memory\n");
+    ctxt->nameNr = 0;
+    ctxt->nameMax = 10;
+    ctxt->name = NULL;
+    ctxt->nodeNr = 0;
+    ctxt->nodeMax = 0;
+    ctxt->node = NULL;
+    ctxt->inputNr = 0;
+    ctxt->inputMax = 0;
+    ctxt->input = NULL;
+    return(-1);
+  }
+  ctxt->nameNr = 0;
+  ctxt->nameMax = 10;
+  ctxt->name = NULL;
+  	
+  if (sax == NULL) ctxt->sax = (xmlSAXHandlerPtr) &htmlDefaultSAXHandler;
+  else {
+    ctxt->sax = sax;
+    memcpy(sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1));
+  }
+  ctxt->userData = ctxt;
+  ctxt->myDoc = NULL;
+  ctxt->wellFormed = 1;
+  ctxt->replaceEntities = 0;
+  ctxt->linenumbers = xmlLineNumbersDefaultValue;
+  ctxt->html = 1;
+  ctxt->vctxt.finishDtd = XML_CTXT_FINISH_DTD_0;
+  ctxt->vctxt.userData = ctxt;
+  ctxt->vctxt.error = xmlParserValidityError;
+  ctxt->vctxt.warning = xmlParserValidityWarning;
+  ctxt->record_info = 0;
+  ctxt->validate = 0;
+  ctxt->nbChars = 0;
+  ctxt->checkIndex = 0;
+  ctxt->catalogs = NULL;
+  xmlInitNodeInfoSeq(&ctxt->node_seq);
+  return(0);
+}
+
+static htmlParserCtxtPtr htmlNewParserCtxt(void)
+{
+  xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) xmlMalloc(sizeof(xmlParserCtxt));
+  if (ctxt == NULL) {
+    rb_raise(rb_eNoMemError, "NewParserCtxt: out of memory\n");
+    return(NULL);
+  }
+  memset(ctxt, 0, sizeof(xmlParserCtxt));
+  if (htmlInitParserCtxt(ctxt) < 0) {
+    htmlFreeParserCtxt(ctxt);
+   return(NULL);
+  }
+  return(ctxt);
+}
+#endif
+
+static void rxml_html_parser_context_free(htmlParserCtxtPtr ctxt)
+{
+  htmlFreeParserCtxt(ctxt);
+}
+
+static VALUE rxml_html_parser_context_wrap(htmlParserCtxtPtr ctxt)
+{
+  return Data_Wrap_Struct(cXMLHtmlParserContext, NULL, rxml_html_parser_context_free, ctxt);
+}
+
+/* call-seq:
+ *    XML::HTMLParser::Context.file(file) -> XML::HTMLParser::Context
+ *
+ * Creates a new parser context based on the specified file or uri.
+ *
+ * Parameters:
+ *
+ *  file - A filename or uri.
+*/
+static VALUE rxml_html_parser_context_file(VALUE klass, VALUE file)
+{
+  htmlParserCtxtPtr ctxt = htmlCreateFileParserCtxt(StringValuePtr(file), NULL);
+  if (!ctxt)
+    rxml_raise(&xmlLastError);
+
+  /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
+     xmlCtxtUseOptionsInternal (called below) initialize slightly different
+     context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
+     sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
+  htmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+
+  return rxml_html_parser_context_wrap(ctxt);
+}
+
+/* call-seq:
+ *    XML::HTMLParser::Context.io(io) -> XML::HTMLParser::Context
+ *
+ * Creates a new parser context based on the specified io object.
+ *
+ * Parameters:
+ *
+ *  io - A ruby IO object.
+*/
+static VALUE rxml_html_parser_context_io(VALUE klass, VALUE io)
+{
+  VALUE result;
+  htmlParserCtxtPtr ctxt;
+  xmlParserInputBufferPtr input;
+  xmlParserInputPtr stream;
+
+  if (NIL_P(io))
+    rb_raise(rb_eTypeError, "Must pass in an IO object");
+
+  input = xmlParserInputBufferCreateIO((xmlInputReadCallback) rxml_read_callback, NULL,
+                                     (void*)io, XML_CHAR_ENCODING_NONE);
+
+  ctxt = htmlNewParserCtxt();
+  if (!ctxt)
+  {
+    xmlFreeParserInputBuffer(input);
+    rxml_raise(&xmlLastError);
+  }
+
+  /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
+     xmlCtxtUseOptionsInternal (called below) initialize slightly different
+     context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
+     sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
+  htmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+
+  stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
+
+  if (!stream)
+  {
+    xmlFreeParserInputBuffer(input);
+    xmlFreeParserCtxt(ctxt);
+    rxml_raise(&xmlLastError);
+  }
+  inputPush(ctxt, stream);
+  result = rxml_html_parser_context_wrap(ctxt);
+
+  /* Attach io object to parser so it won't get freed.*/
+  rb_ivar_set(result, IO_ATTR, io);
+
+  return result;
+}
+
+/* call-seq:
+ *    XML::HTMLParser::Context.string(string) -> XML::HTMLParser::Context
+ *
+ * Creates a new parser context based on the specified string.
+ *
+ * Parameters:
+ *
+ *  string - A string that contains the data to parse.
+*/
+static VALUE rxml_html_parser_context_string(VALUE klass, VALUE string)
+{
+  htmlParserCtxtPtr ctxt;
+  Check_Type(string, T_STRING);
+
+  if (RSTRING_LEN(string) == 0)
+    rb_raise(rb_eArgError, "Must specify a string with one or more characters");
+
+  ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(string),
+                                   (int)RSTRING_LEN(string));
+  if (!ctxt)
+    rxml_raise(&xmlLastError);
+
+  /* This is annoying, but xmlInitParserCtxt (called indirectly above) and 
+     xmlCtxtUseOptionsInternal (called below) initialize slightly different
+     context options, in particular XML_PARSE_NODICT which xmlInitParserCtxt
+     sets to 0 and xmlCtxtUseOptionsInternal sets to 1.  So we have to call both. */
+  htmlCtxtUseOptions(ctxt, rxml_libxml_default_options());
+
+  htmlDefaultSAXHandlerInit();
+  if (ctxt->sax != NULL)
+    memcpy(ctxt->sax, &htmlDefaultSAXHandler, sizeof(xmlSAXHandlerV1));
+  
+  return rxml_html_parser_context_wrap(ctxt);
+}
+
+/*
+ * call-seq:
+ *    context.close -> nil
+ *
+ * Closes the underlying input streams.  This is useful when parsing a large amount of
+ * files and you want to close the files without relying on Ruby's garbage collector
+ * to run.
+ */
+static VALUE rxml_html_parser_context_close(VALUE self)
+{
+  htmlParserCtxtPtr ctxt;
+  xmlParserInputPtr xinput;
+  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+
+  while ((xinput = inputPop(ctxt)) != NULL)
+  {
+	 xmlFreeInputStream(xinput);
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *    context.disable_cdata = (true|false)
+ *
+ * Control whether the CDATA nodes will be created in this context.
+ */
+static VALUE rxml_html_parser_context_disable_cdata_set(VALUE self, VALUE value)
+{
+  htmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+
+  if (ctxt->sax == NULL)
+    rb_raise(rb_eRuntimeError, "Sax handler is not yet set");
+
+  /* LibXML controls this internally with the default SAX handler. */ 
+  if (value)
+    ctxt->sax->cdataBlock = NULL;
+  else
+    ctxt->sax->cdataBlock = htmlDefaultSAXHandler.cdataBlock;
+
+  return value;
+}
+
+/*
+ * call-seq:
+ *    context.options = XML::Parser::Options::NOENT |
+                        XML::Parser::Options::NOCDATA
+ *
+ * Provides control over the execution of a parser.  Valid values 
+ * are the constants defined on XML::Parser::Options.  Multiple
+ * options can be combined by using Bitwise OR (|).
+ */
+static VALUE rxml_html_parser_context_options_set(VALUE self, VALUE options)
+{
+  int xml_options = NUM2INT(options);
+  htmlParserCtxtPtr ctxt;
+  Check_Type(options, T_FIXNUM);
+
+  Data_Get_Struct(self, htmlParserCtxt, ctxt);
+  htmlCtxtUseOptions(ctxt, xml_options);
+
+#if LIBXML_VERSION >= 20707
+  /* Big hack here, but htmlCtxtUseOptions doens't support HTML_PARSE_NOIMPLIED.
+     So do it ourselves. There must be a better way??? */
+  if (xml_options & HTML_PARSE_NOIMPLIED) 
+  {
+	  ctxt->options |= HTML_PARSE_NOIMPLIED;
+  }
+#endif
+
+  return self;
+}
+
+void rxml_init_html_parser_context(void)
+{
+  IO_ATTR = ID2SYM(rb_intern("@io"));
+  cXMLHtmlParserContext = rb_define_class_under(cXMLHtmlParser, "Context", cXMLParserContext);
+
+  rb_define_singleton_method(cXMLHtmlParserContext, "file", rxml_html_parser_context_file, 1);
+  rb_define_singleton_method(cXMLHtmlParserContext, "io", rxml_html_parser_context_io, 1);
+  rb_define_singleton_method(cXMLHtmlParserContext, "string", rxml_html_parser_context_string, 1);
+  rb_define_method(cXMLHtmlParserContext, "close", rxml_html_parser_context_close, 0);
+  rb_define_method(cXMLHtmlParserContext, "disable_cdata=", rxml_html_parser_context_disable_cdata_set, 1);
+  rb_define_method(cXMLHtmlParserContext, "options=", rxml_html_parser_context_options_set, 1);
+}

data/ext/libxml/ruby_xml_html_parser_context.h

@@ -0,0 +1,10 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_HTML_PARSER_CONTEXT__
+#define __RXML_HTML_PARSER_CONTEXT__
+
+extern VALUE cXMLHtmlParserContext;
+
+void rxml_init_html_parser_context(void);
+
+#endif

data/ext/libxml/ruby_xml_html_parser_options.c

@@ -0,0 +1,46 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+
+/* Document-class: LibXML::XML::HTMLParser::Options
+ *
+ * Options to control the operation of the HTMLParser.  The easiest
+ * way to set a parser's options is via the methods
+ * XML::HTMLParser.file, XML::HTMLParser.io or XML::HTMLParser.string.
+ * For additional control, see XML::HTMLParser::Context#options=.
+*/
+
+VALUE mXMLHtmlParserOptions;
+
+void rxml_init_html_parser_options(void)
+{
+  mXMLHtmlParserOptions = rb_define_module_under(cXMLHtmlParser, "Options");
+
+
+#if LIBXML_VERSION >= 20621
+  /* 1: Relax parsing. */
+  rb_define_const(mXMLHtmlParserOptions, "RECOVER", INT2NUM(HTML_PARSE_RECOVER)); 
+#endif
+#if LIBXML_VERSION >= 20708
+  /* 2:  Do not default a doctype if not found */
+  rb_define_const(mXMLHtmlParserOptions, "NODEFDTD", INT2NUM(HTML_PARSE_NODEFDTD));
+#endif
+  /* 32: Suppress error reports. */
+  rb_define_const(mXMLHtmlParserOptions, "NOERROR", INT2NUM(HTML_PARSE_NOERROR)); 
+  /* 64: Suppress warning reports. */
+  rb_define_const(mXMLHtmlParserOptions, "NOWARNING", INT2NUM(HTML_PARSE_NOWARNING));
+  /* 128: Enable pedantic error reporting. */
+  rb_define_const(mXMLHtmlParserOptions, "PEDANTIC", INT2NUM(HTML_PARSE_PEDANTIC)); 
+  /* 256: Remove blank nodes. */
+  rb_define_const(mXMLHtmlParserOptions, "NOBLANKS", INT2NUM(HTML_PARSE_NOBLANKS)); 
+#if LIBXML_VERSION >= 20621
+  /* 2048: Forbid network access. */
+  rb_define_const(mXMLHtmlParserOptions, "NONET", INT2NUM(HTML_PARSE_NONET)); 
+  /* 65536: Compact small text nodes. */
+  rb_define_const(mXMLHtmlParserOptions, "COMPACT", INT2NUM(HTML_PARSE_COMPACT));
+#endif
+#if LIBXML_VERSION >= 20707
+  /* 8192:  Do not add implied html/body... elements */
+  rb_define_const(mXMLHtmlParserOptions, "NOIMPLIED", INT2NUM(HTML_PARSE_NOIMPLIED));
+#endif
+}

data/ext/libxml/ruby_xml_html_parser_options.h

@@ -0,0 +1,10 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_HTML_PARSER_OPTIONS__
+#define __RXML_HTML_PARSER_OPTIONS__
+
+extern VALUE mXMLHtmlParserOptions;
+
+void rxml_init_html_parser_options(void);
+
+#endif

data/ext/libxml/ruby_xml_input_cbg.c

@@ -0,0 +1,191 @@
+/* Author: Martin Povolny (xpovolny@fi.muni.cz) */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_input_cbg.h"
+
+/* Document-class: LibXML::XML::InputCallbacks
+ *
+ * Support for adding custom scheme handlers. */
+
+static ic_scheme *first_scheme = 0;
+
+int ic_match(char const *filename)
+{
+  ic_scheme *scheme;
+
+  //fprintf( stderr, "ic_match: %s\n", filename );
+
+  scheme = first_scheme;
+  while (0 != scheme)
+  {
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST scheme->scheme_name, scheme->name_len))
+    {
+      return 1;
+    }
+    scheme = scheme->next_scheme;
+  }
+  return 0;
+}
+
+void* ic_open(char const *filename)
+{
+  ic_doc_context *ic_doc;
+  ic_scheme *scheme;
+  VALUE res;
+
+  scheme = first_scheme;
+  while (0 != scheme)
+  {
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST scheme->scheme_name, scheme->name_len))
+    {
+      ic_doc = (ic_doc_context*) malloc(sizeof(ic_doc_context));
+
+      res = rb_funcall(scheme->class, rb_intern("document_query"), 1,
+          rb_str_new2(filename));
+
+      ic_doc->buffer = strdup(StringValuePtr(res));
+
+      ic_doc->bpos = ic_doc->buffer;
+      ic_doc->remaining = (int)strlen(ic_doc->buffer);
+      return ic_doc;
+    }
+    scheme = scheme->next_scheme;
+  }
+  return 0;
+}
+
+int ic_read(void *context, char *buffer, int len)
+{
+  ic_doc_context *ic_doc;
+  int ret_len;
+  ic_doc = (ic_doc_context*) context;
+
+  if (len >= ic_doc->remaining)
+  {
+    ret_len = ic_doc->remaining;
+  }
+  else
+  {
+    ret_len = len;
+  }
+  ic_doc->remaining -= ret_len;
+  strncpy(buffer, ic_doc->bpos, ret_len);
+  ic_doc->bpos += ret_len;
+
+  return ret_len;
+}
+
+int ic_close(void *context)
+{
+  ruby_xfree(((ic_doc_context*) context)->buffer);
+  ruby_xfree(context);
+  return 1;
+}
+
+/*
+ * call-seq:
+ *    register
+ *
+ * Register a new set of I/O callback for handling parser input.
+ */
+static VALUE input_callbacks_register_input_callbacks()
+{
+  xmlRegisterInputCallbacks(ic_match, ic_open, ic_read, ic_close);
+  return (Qtrue);
+}
+
+/*
+ * call-seq:
+ *    add_scheme
+ *
+ * No documentation available.
+ */
+static VALUE input_callbacks_add_scheme(VALUE self, VALUE scheme_name,
+    VALUE class)
+{
+  ic_scheme *scheme;
+
+  Check_Type(scheme_name, T_STRING);
+
+  scheme = (ic_scheme*) malloc(sizeof(ic_scheme));
+  scheme->next_scheme = 0;
+  scheme->scheme_name = strdup(StringValuePtr(scheme_name)); /* TODO alloc, dealloc */
+  scheme->name_len = (int)strlen(scheme->scheme_name);
+  scheme->class = class; /* TODO alloc, dealloc */
+
+  //fprintf( stderr, "registered: %s, %d, %s\n", scheme->scheme_name, scheme->name_len, scheme->class );
+
+  if (0 == first_scheme)
+    first_scheme = scheme;
+  else
+  {
+    ic_scheme *pos;
+    pos = first_scheme;
+    while (0 != pos->next_scheme)
+      pos = pos->next_scheme;
+    pos->next_scheme = scheme;
+  }
+
+  return (Qtrue);
+}
+
+/*
+ * call-seq:
+ *    remove_scheme
+ *
+ * No documentation available.
+ */
+static VALUE input_callbacks_remove_scheme(VALUE self, VALUE scheme_name)
+{
+  char *name;
+  ic_scheme *save_scheme, *scheme;
+
+  Check_Type(scheme_name, T_STRING);
+  name = StringValuePtr(scheme_name);
+
+  if (0 == first_scheme)
+    return Qfalse;
+
+  if (!strncmp(name, first_scheme->scheme_name, first_scheme->name_len))
+  {
+    save_scheme = first_scheme->next_scheme;
+
+    ruby_xfree(first_scheme->scheme_name);
+    ruby_xfree(first_scheme);
+
+    first_scheme = save_scheme;
+    return Qtrue;
+  }
+
+  scheme = first_scheme;
+  while (0 != scheme->next_scheme)
+  {
+    if (!strncmp(name, scheme->next_scheme->scheme_name,
+        scheme->next_scheme->name_len))
+    {
+      save_scheme = scheme->next_scheme->next_scheme;
+
+      ruby_xfree(scheme->next_scheme->scheme_name);
+      ruby_xfree(scheme->next_scheme);
+
+      scheme->next_scheme = save_scheme;
+      return Qtrue;
+    }
+    scheme = scheme->next_scheme;
+  }
+  return Qfalse;
+}
+
+void rxml_init_input_callbacks(void)
+{
+  VALUE cInputCallbacks;
+  cInputCallbacks = rb_define_class_under(mXML, "InputCallbacks", rb_cObject);
+
+  /* Class Methods */
+  rb_define_singleton_method(cInputCallbacks, "register",
+      input_callbacks_register_input_callbacks, 0);
+  rb_define_singleton_method(cInputCallbacks, "add_scheme",
+      input_callbacks_add_scheme, 2);
+  rb_define_singleton_method(cInputCallbacks, "remove_scheme",
+      input_callbacks_remove_scheme, 1);
+}