rexpat 0.8.0

data/ext/rexpat/rexpat.c

@@ -0,0 +1,864 @@
+/*
+ * Expat (XML Parser Toolkit) wrapper for Ruby.
+ *
+ * Copyright (C) 2013  吉田正人
+ * Copyright (C) 2026  gemmaro
+ *
+ * This work is licensed under the Ruby license or the Expat license.
+ */
+
+/* The prefix "rbx_" means RuBy Xmlparser.  TODO: Rename to "rbe_",
+   which means RuBy Expat. */
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+#include <expat.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+
+_Static_assert (sizeof (VALUE) >= sizeof (void *),
+                "It must be safe to cast from void* to Ruby's VALUE.");
+
+static VALUE rbe_eError;
+static VALUE rbe_cParser;
+static ID id_on_start_element;
+static ID id_on_end_element;
+static ID id_on_character_data;
+static ID id_on_processing_instruction;
+static ID id_on_default;
+static ID id_on_default_expand;
+static ID id_on_notation_decl;
+static ID id_on_external_entity_ref;
+static ID id_on_comment;
+static ID id_on_start_cdata_section;
+static ID id_on_end_cdata_section;
+static ID id_on_start_namespace_decl;
+static ID id_on_end_namespace_decl;
+static ID id_on_not_standalone;
+static ID id_on_start_doctype_decl;
+static ID id_on_end_doctype_decl;
+static ID id_on_element_decl;
+static ID id_on_attlist_decl;
+static ID id_on_xml_decl;
+static ID id_on_entity_decl;
+static ID id_on_skipped_entity;
+
+struct rbe_parser
+{
+  XML_Parser parser;
+  bool default_current;
+  const XML_Char **last_attrs;
+  VALUE parent;
+};
+
+static void
+rbx_cParser_free (void *ptr)
+{
+  struct rbe_parser *parser = ptr;
+  if (parser->parser)
+    {
+      XML_ParserFree (parser->parser);
+      parser->parser = NULL;
+    }
+  ruby_xfree (parser);
+}
+
+static void
+rbx_cParser_mark (void *ptr)
+{
+  struct rbe_parser *parser = ptr;
+  if (!RB_NIL_P (parser->parent))
+    rb_gc_mark (parser->parent);
+}
+
+static size_t
+rbx_cParser_size (const void *ptr)
+{
+  (void)ptr;
+  return sizeof (struct rbe_parser);
+}
+
+static const rb_data_type_t rbx_cParser_type = {
+  .wrap_struct_name = "rexpat parser",
+  .function = {
+    .dfree = rbx_cParser_free,
+    .dmark = rbx_cParser_mark,
+    .dsize = rbx_cParser_size,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+rbx_cParser_alloc (VALUE klass)
+{
+  struct rbe_parser *parser = ruby_xmalloc (sizeof (struct rbe_parser));
+  *parser = (struct rbe_parser){ .parent = RUBY_Qnil };
+  return rb_data_typed_object_wrap (klass, parser, &rbx_cParser_type);
+}
+
+inline static VALUE
+freeze_object (VALUE obj)
+{
+  rb_obj_freeze_inline (obj);
+  return obj;
+}
+
+static VALUE
+make_content_array (struct rbe_parser *parser, XML_Content *model)
+{
+  VALUE type_name;
+  switch (model->type)
+    {
+    case XML_CTYPE_EMPTY:
+      type_name = rb_id2sym (rb_intern ("empty"));
+      break;
+    case XML_CTYPE_ANY:
+      type_name = rb_id2sym (rb_intern ("any"));
+      break;
+    case XML_CTYPE_MIXED:
+      type_name = rb_id2sym (rb_intern ("mixed"));
+      break;
+    case XML_CTYPE_NAME:
+      type_name = rb_id2sym (rb_intern ("name"));
+      break;
+    case XML_CTYPE_CHOICE:
+      type_name = rb_id2sym (rb_intern ("choice"));
+      break;
+    case XML_CTYPE_SEQ:
+      type_name = rb_id2sym (rb_intern ("seq"));
+      break;
+    }
+  VALUE quant_name;
+  switch (model->quant)
+    {
+    case XML_CQUANT_NONE:
+      quant_name = rb_id2sym (rb_intern ("none"));
+      break;
+    case XML_CQUANT_OPT:
+      quant_name = rb_id2sym (rb_intern ("opt"));
+      break;
+    case XML_CQUANT_REP:
+      quant_name = rb_id2sym (rb_intern ("rep"));
+      break;
+    case XML_CQUANT_PLUS:
+      quant_name = rb_id2sym (rb_intern ("plus"));
+      break;
+    }
+  VALUE ret = rb_ary_new_from_args (
+      3, type_name, quant_name,
+      (model->name ? rb_utf8_str_new_cstr (model->name) : RUBY_Qnil));
+  VALUE children = RUBY_Qnil;
+  if (model->numchildren > 0)
+    {
+      children = rb_ary_new ();
+      for (unsigned int i = 0; i < model->numchildren; i++)
+        {
+          VALUE child = make_content_array (parser, model->children + i);
+          rb_ary_push (children, child);
+        }
+    }
+  rb_ary_push (ret, children);
+  return ret;
+}
+
+static inline VALUE
+standalone_to_ruby (int standalone)
+{
+  switch (standalone)
+    {
+    case -1:
+      return RUBY_Qnil;
+    case 0:
+      return RUBY_Qfalse;
+    case 1:
+      return RUBY_Qtrue;
+    default:
+      rb_raise (rbe_eError, "unreachable");
+      return RUBY_Qnil;
+    }
+}
+
+static void
+on_start_element (void *userdata, const XML_Char *name, const XML_Char **atts)
+{
+  VALUE recv = (VALUE)userdata;
+  struct rbe_parser *parser = rb_check_typeddata (recv, &rbx_cParser_type);
+  parser->last_attrs = atts;
+  VALUE attrhash = rb_hash_new ();
+  while (*atts)
+    {
+      const char *key = *atts++;
+      const char *val = *atts++;
+      rb_hash_aset (attrhash, freeze_object (rb_utf8_str_new_cstr (key)),
+                    rb_utf8_str_new_cstr (val));
+    }
+  rb_funcall ((VALUE)recv, id_on_start_element, 2, rb_utf8_str_new_cstr (name),
+              attrhash);
+}
+
+static void
+end_element_handler (void *userdata, const XML_Char *name)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_end_element, 1, rb_utf8_str_new_cstr (name));
+}
+
+static void
+character_data_handler (void *userdata, const XML_Char *s, int len)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_character_data, 1, rb_utf8_str_new (s, len));
+}
+
+static void
+on_processing_instruction (void *userdata, const XML_Char *target,
+                           const XML_Char *data)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall (recv, id_on_processing_instruction, 2,
+              rb_utf8_str_new_cstr (target), rb_utf8_str_new_cstr (data));
+}
+
+static void
+default_handler (void *userdata, const XML_Char *s, int len)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_default, 1, rb_utf8_str_new (s, len));
+}
+
+static void
+default_expand_handler (void *userdata, const XML_Char *s, int len)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall (recv, id_on_default_expand, 1, rb_utf8_str_new (s, len));
+}
+
+void
+on_notation_decl (void *userdata, const XML_Char *notationName,
+                  const XML_Char *base, const XML_Char *systemId,
+                  const XML_Char *publicId)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_notation_decl, 4,
+              rb_utf8_str_new_cstr (notationName),
+              (base ? rb_utf8_str_new_cstr (base) : RUBY_Qnil),
+              (systemId ? rb_utf8_str_new_cstr (systemId) : RUBY_Qnil),
+              (publicId ? rb_utf8_str_new_cstr (publicId) : RUBY_Qnil));
+}
+
+int
+on_external_entity_ref (XML_Parser parser, const XML_Char *context,
+                        const XML_Char *base, const XML_Char *systemId,
+                        const XML_Char *publicId)
+{
+  VALUE recv;
+
+  recv = (VALUE)XML_GetUserData (parser);
+  rb_funcall (recv, id_on_external_entity_ref, 4,
+              (context ? rb_utf8_str_new_cstr (context) : RUBY_Qnil),
+              (base ? rb_utf8_str_new_cstr (base) : RUBY_Qnil),
+              (systemId ? rb_utf8_str_new_cstr (systemId) : RUBY_Qnil),
+              (publicId ? rb_utf8_str_new_cstr (publicId) : RUBY_Qnil));
+  /* The error status in this handler should be returned
+     by the exception. */
+  return Qnil;
+}
+
+static void
+comment_handler (void *userdata, const XML_Char *s)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_comment, 1, rb_utf8_str_new_cstr (s));
+}
+
+static void
+start_cdata_section_handler (void *userdata)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_start_cdata_section, 0);
+}
+
+static void
+end_cdata_section_handler (void *userdata)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_end_cdata_section, 0);
+}
+
+static void
+start_namespace_decl_handler (void *userdata, const XML_Char *prefix,
+                              const XML_Char *uri)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_start_namespace_decl, 2,
+              (prefix ? rb_utf8_str_new_cstr (prefix) : RUBY_Qnil),
+              (uri ? rb_utf8_str_new_cstr (uri) : RUBY_Qnil));
+}
+
+static void
+end_namespace_decl_handler (void *userdata, const XML_Char *prefix)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_end_namespace_decl, 1,
+              (prefix ? rb_utf8_str_new_cstr (prefix) : RUBY_Qnil));
+}
+
+static int
+not_standalone_handler (void *userdata)
+{
+  VALUE recv = (VALUE)userdata;
+  VALUE v = rb_funcall ((VALUE)recv, id_on_not_standalone, 0);
+  return RB_TEST (v) ? 1 : 0;
+}
+
+static void
+on_start_doctype_decl (void *userdata, const XML_Char *doctypeName,
+                       const XML_Char *sysid, const XML_Char *pubid,
+                       int has_internal_subset)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_start_doctype_decl, 4,
+              rb_utf8_str_new_cstr (doctypeName),
+              (sysid ? rb_utf8_str_new_cstr (sysid) : RUBY_Qnil),
+              (pubid ? rb_utf8_str_new_cstr (pubid) : RUBY_Qnil),
+              (has_internal_subset ? RUBY_Qtrue : RUBY_Qfalse));
+}
+
+static void
+end_doctype_decl_handler (void *userdata)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_end_doctype_decl, 0);
+}
+
+static void
+element_decl_handler (void *userdata, const XML_Char *name, XML_Content *model)
+{
+  VALUE recv = (VALUE)userdata;
+  struct rbe_parser *parser = rb_check_typeddata (recv, &rbx_cParser_type);
+  VALUE content = make_content_array (parser, model);
+  rb_funcall ((VALUE)recv, id_on_element_decl, 2, rb_utf8_str_new_cstr (name),
+              content);
+}
+
+static void
+attlist_decl_handler (void *userdata, const XML_Char *elname,
+                      const XML_Char *attname, const XML_Char *att_type,
+                      const XML_Char *dflt, int isrequired)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_attlist_decl, 5,
+              rb_utf8_str_new_cstr (elname), rb_utf8_str_new_cstr (attname),
+              rb_utf8_str_new_cstr (att_type),
+              (dflt ? rb_utf8_str_new_cstr (dflt) : RUBY_Qnil),
+              (isrequired ? RUBY_Qtrue : RUBY_Qfalse));
+}
+
+static void
+xml_decl_handler (void *userdata, const XML_Char *version,
+                  const XML_Char *encoding, int standalone)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_xml_decl, 3,
+              (version ? rb_utf8_str_new_cstr (version) : RUBY_Qnil),
+              (encoding ? rb_utf8_str_new_cstr (encoding) : RUBY_Qnil),
+              standalone_to_ruby (standalone));
+}
+
+static void
+on_entity_decl (void *userdata, const XML_Char *entityName,
+                int is_parameter_entity, const XML_Char *value,
+                int value_length, const XML_Char *base,
+                const XML_Char *systemId, const XML_Char *publicId,
+                const XML_Char *notationName)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall (
+      (VALUE)recv, id_on_entity_decl, 7, rb_utf8_str_new_cstr (entityName),
+      (is_parameter_entity ? RUBY_Qtrue : RUBY_Qfalse),
+      rb_utf8_str_new (value, value_length),
+      (base ? rb_utf8_str_new_cstr (base) : RUBY_Qnil),
+      (systemId ? rb_utf8_str_new_cstr (systemId) : RUBY_Qnil),
+      (publicId ? rb_utf8_str_new_cstr (publicId) : RUBY_Qnil),
+      (notationName ? rb_utf8_str_new_cstr (notationName) : RUBY_Qnil));
+}
+
+static void
+on_skipped_entity (void *userdata, const XML_Char *entityName,
+                   int is_parameter_entity)
+{
+  VALUE recv = (VALUE)userdata;
+  rb_funcall ((VALUE)recv, id_on_skipped_entity, 2,
+              rb_utf8_str_new_cstr (entityName),
+              is_parameter_entity ? RUBY_Qtrue : RUBY_Qfalse);
+}
+
+static VALUE
+rbx_cParser_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+
+  ID kwargs_ids[] = { rb_intern ("encoding"), rb_intern ("nssep") };
+  VALUE kwargs_vals[sizeof (kwargs_ids) / sizeof (kwargs_ids[0])] = { 0 };
+  rb_get_kwargs (kwargs, kwargs_ids, 0, 2, kwargs_vals);
+  VALUE encoding = kwargs_vals[0], nssep = kwargs_vals[1];
+
+  const char *enc
+      = RB_NIL_OR_UNDEF_P (encoding) ? NULL : rb_string_value_cstr (&encoding);
+  const char *sep
+      = RB_NIL_OR_UNDEF_P (nssep) ? NULL : rb_string_value_cstr (&nssep);
+
+  struct rbe_parser *parser = rb_check_typeddata (self, &rbx_cParser_type);
+  *parser = (struct rbe_parser){
+    .parser
+    = sep == NULL ? XML_ParserCreate (enc) : XML_ParserCreateNS (enc, sep[0]),
+    .parent = RUBY_Qnil,
+  };
+  if (!parser->parser)
+    rb_raise (rbe_eError, "cannot create parser");
+
+  XML_SetUserData (parser->parser, (void *)self);
+  return self;
+}
+
+static VALUE
+rbe_cParser_m_external_entity_parser (int argc, VALUE *argv, VALUE self)
+{
+  struct rbe_parser *parser = rb_check_typeddata (self, &rbx_cParser_type);
+
+  VALUE context, kwargs;
+  rb_scan_args (argc, argv, "1:", &context, &kwargs);
+
+  const char *ctx = rb_string_value_cstr (&context);
+
+  ID kwargs_ids[] = { rb_intern ("encoding") };
+  VALUE kwargs_vals[sizeof (kwargs_ids) / sizeof (kwargs_ids[0])] = { 0 };
+  rb_get_kwargs (kwargs, kwargs_ids, 0, 1, kwargs_vals);
+  VALUE encoding = kwargs_vals[0];
+  const char *enc
+      = RB_NIL_OR_UNDEF_P (encoding) ? NULL : rb_string_value_cstr (&encoding);
+
+  VALUE eparser = rb_obj_alloc (rbe_cParser);
+  struct rbe_parser *ep = rb_check_typeddata (eparser, &rbx_cParser_type);
+  *ep = (struct rbe_parser){ .parser = XML_ExternalEntityParserCreate (
+                                 parser->parser, ctx, enc),
+                             .parent = self };
+  if (!ep->parser)
+    rb_raise (rbe_eError, "cannot create external entity parser");
+  XML_SetUserData (ep->parser, (void *)eparser);
+  return eparser;
+}
+
+static VALUE
+rbe_cParser_m_reset (int argc, VALUE *argv, VALUE obj)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+  ID kwargs_ids[] = { rb_intern ("encoding") };
+  VALUE kwargs_vals[sizeof (kwargs_ids) / sizeof (kwargs_ids[0])] = { 0 };
+  rb_get_kwargs (kwargs, kwargs_ids, 0, 1, kwargs_vals);
+  VALUE encoding_obj = kwargs_vals[0];
+  const char *encoding = RB_NIL_OR_UNDEF_P (encoding_obj)
+                             ? NULL
+                             : rb_string_value_cstr (&encoding_obj);
+
+  XML_ParserReset (parser->parser, encoding);
+
+  XML_SetUserData (parser->parser, (void *)obj);
+  parser->default_current = false;
+  parser->last_attrs = NULL;
+
+  return obj;
+}
+
+static void
+setup_event_handlers (struct rbe_parser *parser, VALUE obj)
+{
+  XML_StartElementHandler start = NULL;
+  XML_EndElementHandler end = NULL;
+  XML_StartCdataSectionHandler start_c = NULL;
+  XML_EndCdataSectionHandler end_c = NULL;
+  XML_StartNamespaceDeclHandler start_ns = NULL;
+  XML_EndNamespaceDeclHandler end_ns = NULL;
+  XML_StartDoctypeDeclHandler start_doctype = NULL;
+  XML_EndDoctypeDeclHandler end_doctype = NULL;
+
+  if (rb_respond_to (obj, id_on_start_element))
+    start = on_start_element;
+  if (rb_respond_to (obj, id_on_end_element))
+    end = end_element_handler;
+  if (start || end)
+    XML_SetElementHandler (parser->parser, start, end);
+  if (rb_respond_to (obj, id_on_character_data))
+    XML_SetCharacterDataHandler (parser->parser, character_data_handler);
+  if (rb_respond_to (obj, id_on_processing_instruction))
+    XML_SetProcessingInstructionHandler (parser->parser,
+                                         on_processing_instruction);
+  if (rb_respond_to (obj, id_on_default_expand))
+    XML_SetDefaultHandlerExpand (parser->parser, default_expand_handler);
+  else if (rb_respond_to (obj, id_on_default))
+    XML_SetDefaultHandler (parser->parser, default_handler);
+  if (rb_respond_to (obj, id_on_notation_decl))
+    XML_SetNotationDeclHandler (parser->parser, on_notation_decl);
+  if (rb_respond_to (obj, id_on_external_entity_ref))
+    XML_SetExternalEntityRefHandler (parser->parser, on_external_entity_ref);
+  if (rb_respond_to (obj, id_on_comment))
+    XML_SetCommentHandler (parser->parser, comment_handler);
+
+  if (rb_respond_to (obj, id_on_start_cdata_section))
+    start_c = start_cdata_section_handler;
+  if (rb_respond_to (obj, id_on_end_cdata_section))
+    end_c = end_cdata_section_handler;
+  if (start_c || end_c)
+    XML_SetCdataSectionHandler (parser->parser, start_c, end_c);
+
+  if (rb_respond_to (obj, id_on_start_namespace_decl))
+    start_ns = start_namespace_decl_handler;
+  if (rb_respond_to (obj, id_on_end_namespace_decl))
+    end_ns = end_namespace_decl_handler;
+  if (start_ns || end_ns)
+    XML_SetNamespaceDeclHandler (parser->parser, start_ns, end_ns);
+  if (rb_respond_to (obj, id_on_not_standalone))
+    XML_SetNotStandaloneHandler (parser->parser, not_standalone_handler);
+  if (rb_respond_to (obj, id_on_start_doctype_decl))
+    start_doctype = on_start_doctype_decl;
+  if (rb_respond_to (obj, id_on_end_doctype_decl))
+    end_doctype = end_doctype_decl_handler;
+  if (start_doctype || end_doctype)
+    XML_SetDoctypeDeclHandler (parser->parser, start_doctype, end_doctype);
+  if (rb_respond_to (obj, id_on_element_decl))
+    XML_SetElementDeclHandler (parser->parser, element_decl_handler);
+  if (rb_respond_to (obj, id_on_attlist_decl))
+    XML_SetAttlistDeclHandler (parser->parser, attlist_decl_handler);
+  if (rb_respond_to (obj, id_on_xml_decl))
+    XML_SetXmlDeclHandler (parser->parser, xml_decl_handler);
+  if (rb_respond_to (obj, id_on_entity_decl))
+    XML_SetEntityDeclHandler (parser->parser, on_entity_decl);
+  if (rb_respond_to (obj, id_on_skipped_entity))
+    XML_SetSkippedEntityHandler (parser->parser, on_skipped_entity);
+}
+
+static VALUE
+rbe_cParser_m_parse (int argc, VALUE *argv, VALUE obj)
+{
+  enum XML_Status ret;
+
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+
+  VALUE str, kwargs;
+  rb_scan_args (argc, argv, "01:", &str, &kwargs);
+  ID kwargs_ids[] = { rb_intern ("final") };
+  VALUE kwargs_vals[sizeof (kwargs_ids) / sizeof (kwargs_ids[0])] = { 0 };
+  rb_get_kwargs (kwargs, kwargs_ids, 0, 1, kwargs_vals);
+  VALUE final_obj = kwargs_vals[0];
+  int final = RB_UNDEF_P (final_obj) ? RUBY_Qtrue : RB_TEST (final_obj);
+
+  setup_event_handlers (parser, obj);
+
+  if (!NIL_P (str))
+    {
+      ret = XML_Parse (parser->parser, RSTRING_PTR (str),
+                       (int)RSTRING_LEN (str), final);
+      enum XML_Error err = XML_GetErrorCode (parser->parser);
+      if (final && err == XML_ERROR_UNKNOWN_ENCODING)
+        rb_raise (rbe_eError, "unknown encoding");
+    }
+  else
+    ret = XML_Parse (parser->parser, NULL, 0, final);
+
+  switch (ret)
+    {
+    case XML_STATUS_ERROR:
+      {
+        enum XML_Error err = XML_GetErrorCode (parser->parser);
+        const XML_LChar *message = XML_ErrorString (err);
+        rb_raise (rbe_eError, "fatal parsing error: %s", message);
+        return RUBY_Qnil;
+      }
+    case XML_STATUS_OK:
+      return RUBY_Qnil;
+
+    case XML_STATUS_SUSPENDED:
+      rb_raise (rbe_eError, "unexpected error");
+      return RUBY_Qnil;
+    }
+}
+
+static VALUE
+rbe_cParser_m_default_current (VALUE obj)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  XML_DefaultCurrent (parser->parser);
+  return Qnil;
+}
+
+static VALUE
+rbe_cParser_m_line (VALUE obj)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  XML_Size line = XML_GetCurrentLineNumber (parser->parser);
+  return rb_ulong2num_inline (line);
+}
+
+static VALUE
+rbe_cParser_m_column (VALUE obj)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  XML_Size column = XML_GetCurrentColumnNumber (parser->parser);
+  return rb_ulong2num_inline (column);
+}
+
+static VALUE
+rbe_cParser_m_byte_index (VALUE obj)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  XML_Index pos = XML_GetCurrentByteIndex (parser->parser);
+  return rb_long2num_inline (pos);
+}
+
+static VALUE
+rbe_cParser_m_set_base (VALUE obj, VALUE base)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  enum XML_Status status
+      = XML_SetBase (parser->parser, rb_string_value_cstr (&base));
+  switch (status)
+    {
+    case XML_STATUS_ERROR:
+      rb_raise (rbe_eError, "out of memory");
+      return RUBY_Qnil;
+    case XML_STATUS_OK:
+      return RUBY_Qnil;
+    case XML_STATUS_SUSPENDED:
+      rb_raise (rbe_eError, "unexpected suspended error");
+      return RUBY_Qnil;
+    }
+}
+
+static VALUE
+rbe_cParser_getBase (VALUE obj)
+{
+  const XML_Char *ret;
+
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  ret = XML_GetBase (parser->parser);
+  if (!ret)
+    return Qnil;
+
+  return rb_utf8_str_new_cstr (ret);
+}
+
+static VALUE
+rbe_cParser_m_specified_attributes (VALUE obj)
+{
+  const XML_Char **atts;
+  VALUE attrarray;
+
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  atts = parser->last_attrs;
+  if (!atts)
+    return Qnil;
+  const int count = XML_GetSpecifiedAttributeCount (parser->parser);
+  attrarray = rb_ary_new_capa (count);
+  for (int index = 0; index < count; index += 2)
+    rb_ary_push (attrarray, rb_utf8_str_new_cstr (*(atts + index)));
+
+  return attrarray;
+}
+
+static VALUE
+rbe_cParser_m_byte_count (VALUE obj)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  return rb_int2num_inline (XML_GetCurrentByteCount (parser->parser));
+}
+
+static VALUE
+rbe_cParser_m_set_param_entity_parsing (VALUE obj, VALUE parsing)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+
+  ID id = RB_SYM2ID (parsing);
+  enum XML_ParamEntityParsing p
+      = rb_intern ("never") == id ? XML_PARAM_ENTITY_PARSING_NEVER
+        : rb_intern ("unless_standalone") == id
+            ? XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE
+        : rb_intern ("always") == id
+            ? XML_PARAM_ENTITY_PARSING_ALWAYS
+            : (rb_raise (rb_eArgError, "unexpected parsing value"),
+               0 /* dummy */);
+  if (XML_SetParamEntityParsing (parser->parser, p) == 0)
+    rb_raise (rbe_eError, "failed or no effect to set parsing control");
+  return RUBY_Qnil;
+}
+
+static VALUE
+rbe_s_expat_version (VALUE obj)
+{
+  (void)obj;
+  return rb_utf8_str_new_cstr (XML_ExpatVersion ());
+}
+
+static VALUE
+rbe_cParser_m_set_return_ns_triplet (VALUE obj, VALUE do_nst)
+{
+  int nst;
+
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  switch (TYPE (do_nst))
+    {
+    case T_TRUE:
+      nst = 1;
+      break;
+    case T_FALSE:
+      nst = 0;
+      break;
+    default:
+      rb_raise (rb_eTypeError, "not valid value");
+    }
+  XML_SetReturnNSTriplet (parser->parser, nst);
+
+  return Qnil;
+}
+
+static VALUE
+rbe_cParser_m_input_context (VALUE obj)
+{
+  const char *buffer;
+  int offset;
+  int size;
+
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  buffer = XML_GetInputContext (parser->parser, &offset, &size);
+  return buffer && size > 0
+             ? rb_ary_new_from_args (2, rb_utf8_str_new (buffer, size),
+                                     rb_int2num_inline (offset))
+             : Qnil;
+}
+
+static VALUE
+rbe_cParser_m_id_attribute (VALUE obj)
+{
+  int idattr;
+  const XML_Char **atts;
+
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  atts = parser->last_attrs;
+  if (!atts)
+    return Qnil;
+  idattr = XML_GetIdAttributeIndex (parser->parser);
+  if (idattr < 0)
+    return Qnil;
+  return rb_utf8_str_new_cstr (atts[idattr]);
+}
+
+static VALUE
+rbe_cParser_m_use_foreign_dtd (VALUE obj, VALUE useDTD)
+{
+  struct rbe_parser *parser = rb_check_typeddata (obj, &rbx_cParser_type);
+  enum XML_Error ret = XML_UseForeignDTD (parser->parser, RB_TEST (useDTD));
+  switch (ret)
+    {
+    case XML_ERROR_NONE:
+      return RUBY_Qnil;
+    case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
+      rb_raise (rbe_eError, "cannot change feature once parsing");
+      return RUBY_Qnil;
+    case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
+      rb_raise (rbe_eError, "this feature requires XML DTD; XML_DTD was not "
+                            "enabled when compiling Expat");
+      return RUBY_Qnil;
+    case XML_ERROR_INVALID_ARGUMENT:
+      rb_raise (rbe_eError, "parser is empty");
+      return RUBY_Qnil;
+    default:
+      rb_raise (rbe_eError, "unexpected error");
+      return RUBY_Qnil;
+    }
+}
+
+static VALUE
+rbe_s_features (VALUE obj)
+{
+  (void)obj;
+  const XML_Feature *list;
+  VALUE ret = rb_hash_new ();
+
+  list = XML_GetFeatureList ();
+  while (list && list->feature)
+    {
+      rb_hash_aset (ret, freeze_object (rb_utf8_str_new_cstr (list->name)),
+                    INT2NUM (list->value));
+      list++;
+    }
+
+  return ret;
+}
+
+void
+Init_rexpat ()
+{
+  rbe_cParser = rb_define_class ("RExpat", rb_cObject);
+  rb_define_alloc_func (rbe_cParser, rbx_cParser_alloc);
+
+  rbe_eError = rb_define_class_under (rbe_cParser, "Error", rb_eStandardError);
+
+  rb_define_singleton_method (rbe_cParser, "expat_version",
+                              rbe_s_expat_version, 0);
+  rb_define_method (rbe_cParser, "initialize", rbx_cParser_m_initialize, -1);
+  rb_define_method (rbe_cParser, "external_entity_parser",
+                    rbe_cParser_m_external_entity_parser, -1);
+  rb_define_method (rbe_cParser, "parse", rbe_cParser_m_parse, -1);
+  rb_define_method (rbe_cParser, "default_current",
+                    rbe_cParser_m_default_current, 0);
+  rb_define_method (rbe_cParser, "line", rbe_cParser_m_line, 0);
+  rb_define_method (rbe_cParser, "column", rbe_cParser_m_column, 0);
+  rb_define_method (rbe_cParser, "byte_index", rbe_cParser_m_byte_index, 0);
+  rb_define_method (rbe_cParser, "base=", rbe_cParser_m_set_base, 1);
+  rb_define_method (rbe_cParser, "getBase", rbe_cParser_getBase, 0);
+  rb_define_method (rbe_cParser, "specified_attributes",
+                    rbe_cParser_m_specified_attributes, 0);
+  rb_define_method (rbe_cParser, "byte_count", rbe_cParser_m_byte_count, 0);
+  rb_define_method (rbe_cParser, "param_entity_parsing=",
+                    rbe_cParser_m_set_param_entity_parsing, 1);
+  rb_define_method (rbe_cParser,
+                    "return_ns_triplet=", rbe_cParser_m_set_return_ns_triplet,
+                    1);
+  rb_define_method (rbe_cParser, "input_context", rbe_cParser_m_input_context,
+                    0);
+  rb_define_method (rbe_cParser, "id_attribute", rbe_cParser_m_id_attribute,
+                    0);
+
+  rb_define_method (rbe_cParser, "reset", rbe_cParser_m_reset, -1);
+
+  rb_define_method (rbe_cParser,
+                    "use_foreign_dtd=", rbe_cParser_m_use_foreign_dtd, 1);
+  rb_define_singleton_method (rbe_cParser, "features", rbe_s_features, 0);
+
+  id_on_start_element = rb_intern ("on_start_element");
+  id_on_end_element = rb_intern ("on_end_element");
+  id_on_character_data = rb_intern ("on_character_data");
+  id_on_processing_instruction = rb_intern ("on_processing_instruction");
+  id_on_default = rb_intern ("on_default");
+  id_on_notation_decl = rb_intern ("on_notation_decl");
+  id_on_external_entity_ref = rb_intern ("on_external_entity_ref");
+  id_on_default_expand = rb_intern ("on_default_expand");
+  id_on_comment = rb_intern ("on_comment");
+  id_on_start_cdata_section = rb_intern ("on_start_cdata_section");
+  id_on_end_cdata_section = rb_intern ("on_end_cdata_section");
+  id_on_start_namespace_decl = rb_intern ("on_start_namespace_decl");
+  id_on_end_namespace_decl = rb_intern ("on_end_namespace_decl");
+  id_on_not_standalone = rb_intern ("on_not_standalone");
+  id_on_start_doctype_decl = rb_intern ("on_start_doctype_decl");
+  id_on_end_doctype_decl = rb_intern ("on_end_doctype_decl");
+  id_on_element_decl = rb_intern ("on_element_decl");
+  id_on_attlist_decl = rb_intern ("on_attlist_decl");
+  id_on_xml_decl = rb_intern ("on_xml_decl");
+  id_on_entity_decl = rb_intern ("on_entity_decl");
+  id_on_skipped_entity = rb_intern ("on_skipped_entity");
+}