md4c 0.0.1

data/ext/md4c/rb_md4c.c

@@ -0,0 +1,741 @@
+/*
+ * Copyright (C) 2026  gemmaro
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "rb_md4c.h"
+#include <md4c-html.h>
+#include <md4c.h>
+#include <ruby.h>
+#include <stddef.h>
+
+/* rbm_ prefix means "Ruby MD4C". */
+
+static VALUE rb_mMD4C, rbm_cParser, rbm_cStringAttribute, /* blocks --> */
+    rbm_cUnorderedList, rbm_cOrderedList, rbm_cListItem, rbm_cHeading,
+    rbm_cCodeBlock, rbm_cTable, rbm_cTableHeader, rbm_cTableData,
+    /* spans --> */ rbm_cAnchor, rbm_cImage, rbm_cWikiLink,
+    /* texts --> */ rbm_cNormalText, rbm_cNullChar, rbm_cHardBreak,
+    rbm_cSoftBreak, rbm_cEntity, rbm_cCodeText, rbm_cHTMLText,
+    rbm_cLaTeXMathText, /* error --> */ rbm_eError;
+
+struct rbm_cParser
+{
+  unsigned flags;
+  VALUE on_enter_block, on_leave_block, on_enter_span, on_leave_span, on_text;
+};
+
+static size_t
+rbm_cParser_size (const void *ptr)
+{
+  return sizeof (struct rbm_cParser);
+}
+
+static void
+rbm_cParser_mark (void *ptr)
+{
+  struct rbm_cParser *p = ptr;
+  rb_gc_mark_movable (p->on_enter_block);
+  rb_gc_mark_movable (p->on_leave_block);
+  rb_gc_mark_movable (p->on_enter_span);
+  rb_gc_mark_movable (p->on_leave_span);
+  rb_gc_mark_movable (p->on_text);
+}
+
+static void
+rbm_cParser_compact (void *ptr)
+{
+  struct rbm_cParser *p = ptr;
+  p->on_enter_block = rb_gc_location (p->on_enter_block);
+  p->on_leave_block = rb_gc_location (p->on_leave_block);
+  p->on_enter_span = rb_gc_location (p->on_enter_span);
+  p->on_leave_span = rb_gc_location (p->on_leave_span);
+  p->on_text = rb_gc_location (p->on_text);
+}
+
+static const rb_data_type_t rbm_cParser_type
+    = { .wrap_struct_name = "MD4C parser",
+        .function = { .dfree = RUBY_DEFAULT_FREE,
+                      .dmark = rbm_cParser_mark,
+                      .dcompact = rbm_cParser_compact,
+                      .dsize = rbm_cParser_size },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+VALUE
+rbm_cParser_alloc (VALUE self)
+{
+  struct rbm_cParser *p = ruby_xmalloc (sizeof (struct rbm_cParser));
+  return rb_data_typed_object_wrap (rbm_cParser, p, &rbm_cParser_type);
+}
+
+#define PARSER_FLAGS                                                          \
+  rb_intern ("collapse_whitespace"), rb_intern ("permissive_atx_headers"),    \
+      rb_intern ("permissive_url_autolinks"),                                 \
+      rb_intern ("permissive_email_autolinks"),                               \
+      rb_intern ("no_indented_codeblocks"), rb_intern ("no_html_blocks"),     \
+      rb_intern ("no_html_spans"), rb_intern ("tables"),                      \
+      rb_intern ("strikethrough"), rb_intern ("permissive_www_autolinks"),    \
+      rb_intern ("task_lists"), rb_intern ("latex_math_spans"),               \
+      rb_intern ("wiki_links"), rb_intern ("underline"),                      \
+      rb_intern ("hard_soft_breaks"), rb_intern ("permissive_autolinks"),     \
+      rb_intern ("no_html"), rb_intern ("commonmark"), rb_intern ("github")
+
+static unsigned
+rbm_get_parser_flags (ID kwargs_vals[])
+{
+  unsigned flags = 0;
+
+  if (!RB_UNDEF_P (kwargs_vals[0]) && RB_TEST (kwargs_vals[0]))
+    flags |= MD_FLAG_COLLAPSEWHITESPACE;
+
+  if (!RB_UNDEF_P (kwargs_vals[1]) && RB_TEST (kwargs_vals[1]))
+    flags |= MD_FLAG_PERMISSIVEATXHEADERS;
+
+  if (!RB_UNDEF_P (kwargs_vals[2]) && RB_TEST (kwargs_vals[2]))
+    flags |= MD_FLAG_PERMISSIVEURLAUTOLINKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[3]) && RB_TEST (kwargs_vals[3]))
+    flags |= MD_FLAG_PERMISSIVEEMAILAUTOLINKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[4]) && RB_TEST (kwargs_vals[4]))
+    flags |= MD_FLAG_NOINDENTEDCODEBLOCKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[5]) && RB_TEST (kwargs_vals[5]))
+    flags |= MD_FLAG_NOHTMLBLOCKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[6]) && RB_TEST (kwargs_vals[6]))
+    flags |= MD_FLAG_NOHTMLSPANS;
+
+  if (!RB_UNDEF_P (kwargs_vals[7]) && RB_TEST (kwargs_vals[7]))
+    flags |= MD_FLAG_TABLES;
+
+  if (!RB_UNDEF_P (kwargs_vals[8]) && RB_TEST (kwargs_vals[8]))
+    flags |= MD_FLAG_STRIKETHROUGH;
+
+  if (!RB_UNDEF_P (kwargs_vals[9]) && RB_TEST (kwargs_vals[9]))
+    flags |= MD_FLAG_PERMISSIVEWWWAUTOLINKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[10]) && RB_TEST (kwargs_vals[10]))
+    flags |= MD_FLAG_TASKLISTS;
+
+  if (!RB_UNDEF_P (kwargs_vals[11]) && RB_TEST (kwargs_vals[11]))
+    flags |= MD_FLAG_LATEXMATHSPANS;
+
+  if (!RB_UNDEF_P (kwargs_vals[12]) && RB_TEST (kwargs_vals[12]))
+    flags |= MD_FLAG_WIKILINKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[13]) && RB_TEST (kwargs_vals[13]))
+    flags |= MD_FLAG_UNDERLINE;
+
+  if (!RB_UNDEF_P (kwargs_vals[14]) && RB_TEST (kwargs_vals[14]))
+    flags |= MD_FLAG_HARD_SOFT_BREAKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[15]) && RB_TEST (kwargs_vals[15]))
+    flags |= MD_FLAG_PERMISSIVEAUTOLINKS;
+
+  if (!RB_UNDEF_P (kwargs_vals[16]) && RB_TEST (kwargs_vals[16]))
+    flags |= MD_FLAG_NOHTML;
+
+  if (!RB_UNDEF_P (kwargs_vals[17]) && RB_TEST (kwargs_vals[17]))
+    flags |= MD_DIALECT_COMMONMARK;
+
+  if (!RB_UNDEF_P (kwargs_vals[18]) && RB_TEST (kwargs_vals[18]))
+    flags |= MD_DIALECT_GITHUB;
+
+  return flags;
+}
+
+static VALUE
+rbm_cParser_m_initialize (int argc, VALUE *argv, VALUE self)
+{
+  VALUE kwargs;
+  rb_scan_args (argc, argv, ":", &kwargs);
+  ID kwargs_ids[] = { PARSER_FLAGS };
+  VALUE kwargs_vals[sizeof (kwargs_ids) / sizeof (kwargs_ids[0])] = { 0 };
+  rb_get_kwargs (kwargs, kwargs_ids, 0,
+                 sizeof (kwargs_ids) / sizeof (kwargs_ids[0]), kwargs_vals);
+
+  struct rbm_cParser *p = RTYPEDDATA_DATA (self);
+  *p = (struct rbm_cParser){ .flags = rbm_get_parser_flags (kwargs_vals) };
+  return self;
+}
+
+static VALUE
+rbm_cParser_m_on_enter_block (VALUE self)
+{
+  struct rbm_cParser *p = RTYPEDDATA_DATA (self);
+  return p->on_enter_block = rb_block_proc ();
+}
+
+static VALUE
+rbm_cParser_m_on_leave_block (VALUE self)
+{
+  struct rbm_cParser *p = RTYPEDDATA_DATA (self);
+  return p->on_leave_block = rb_block_proc ();
+}
+
+static VALUE
+rbm_cParser_m_on_enter_span (VALUE self)
+{
+  struct rbm_cParser *p = RTYPEDDATA_DATA (self);
+  return p->on_enter_span = rb_block_proc ();
+}
+
+static VALUE
+rbm_cParser_m_on_leave_span (VALUE self)
+{
+  struct rbm_cParser *p = RTYPEDDATA_DATA (self);
+  return p->on_leave_span = rb_block_proc ();
+}
+
+static VALUE
+rbm_cParser_m_on_text (VALUE self)
+{
+  struct rbm_cParser *p = RTYPEDDATA_DATA (self);
+  return p->on_text = rb_block_proc ();
+}
+
+static size_t
+rbm_cStringAttribute_size (const void *ptr)
+{
+  return sizeof (MD_ATTRIBUTE);
+}
+
+static const rb_data_type_t rbm_cStringAttribute_type
+    = { .wrap_struct_name = "MD4C string attribute",
+        .function
+        = { .dfree = RUBY_DEFAULT_FREE, .dsize = rbm_cStringAttribute_size },
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY };
+
+static VALUE
+rbm_cStringAttribute_alloc (VALUE self)
+{
+  MD_BLOCK_CODE_DETAIL *attr = ruby_xmalloc (sizeof (MD_ATTRIBUTE));
+  return rb_data_typed_object_wrap (rbm_cStringAttribute, attr,
+                                    &rbm_cStringAttribute_type);
+}
+
+static VALUE
+rbm_get_text_class (MD_TEXTTYPE type)
+{
+  switch (type)
+    {
+    case MD_TEXT_NORMAL:
+      return rbm_cNormalText;
+
+    case MD_TEXT_NULLCHAR:
+      return rbm_cNullChar;
+
+    case MD_TEXT_BR:
+      return rbm_cSoftBreak;
+
+    case MD_TEXT_SOFTBR:
+      return rbm_cHardBreak;
+
+    case MD_TEXT_ENTITY:
+      return rbm_cEntity;
+
+    case MD_TEXT_CODE:
+      return rbm_cCodeText;
+
+    case MD_TEXT_HTML:
+      return rbm_cHTMLText;
+
+    case MD_TEXT_LATEXMATH:
+      return rbm_cLaTeXMathText;
+    }
+}
+
+static VALUE
+rbm_cStringAttribute_m_each (VALUE self)
+{
+  RETURN_ENUMERATOR (self, 0, NULL);
+
+  MD_ATTRIBUTE *attr = RTYPEDDATA_DATA (self);
+  size_t index = 0;
+  while (attr->substr_offsets[index] >= attr->size)
+    {
+      VALUE klass = rbm_get_text_class (attr->substr_types[index]);
+      VALUE substr = rb_class_new_instance (0, NULL, klass);
+      VALUE content = rb_str_new (attr->text + attr->substr_offsets[index],
+                                  attr->substr_offsets[index + 1]
+                                      - attr->substr_offsets[index]);
+      rb_iv_set (substr, "@content", content);
+      rb_yield (substr);
+    }
+  return RUBY_Qnil;
+}
+
+static VALUE
+rbm_callback_block_arguments (MD_BLOCKTYPE type, void *detail)
+{
+  VALUE arg;
+  switch (type)
+    {
+    case MD_BLOCK_DOC:
+      arg = rb_id2sym (rb_intern ("document"));
+      break;
+
+    case MD_BLOCK_QUOTE:
+      arg = rb_id2sym (rb_intern ("quote"));
+      break;
+
+    case MD_BLOCK_UL:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cUnorderedList);
+        MD_BLOCK_UL_DETAIL *d = detail;
+        rb_iv_set (arg, "@tight", d->is_tight ? RUBY_Qtrue : RUBY_Qfalse);
+
+        VALUE mark = rb_str_new (&d->mark, 1);
+        rb_iv_set (arg, "@mark", mark);
+        break;
+      }
+
+    case MD_BLOCK_OL:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cOrderedList);
+        MD_BLOCK_OL_DETAIL *d = detail;
+
+        VALUE start = rb_uint2num_inline (d->start);
+        rb_iv_set (arg, "@start", start);
+
+        rb_iv_set (arg, "@tight", d->is_tight ? RUBY_Qtrue : RUBY_Qfalse);
+
+        VALUE delimiter = rb_str_new (&d->mark_delimiter, 1);
+        rb_iv_set (arg, "@mark_delimiter", delimiter);
+        break;
+      }
+
+    case MD_BLOCK_LI:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cListItem);
+        MD_BLOCK_LI_DETAIL *d = detail;
+        rb_iv_set (arg, "@task", d->is_task ? RUBY_Qtrue : RUBY_Qfalse);
+
+        VALUE task_mark
+            = d->is_task ? rb_str_new (&d->task_mark, 1) : RUBY_Qnil;
+        rb_iv_set (arg, "@task_mark", task_mark);
+
+        VALUE offset = rb_uint2num_inline (d->task_mark_offset);
+        rb_iv_set (arg, "@task_mark_offset", offset);
+        break;
+      }
+
+    case MD_BLOCK_HR:
+      /* https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/hr
+       */
+      arg = rb_id2sym (rb_intern ("thematic_break"));
+      break;
+
+    case MD_BLOCK_H:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cHeading);
+        MD_BLOCK_H_DETAIL *d = detail;
+
+        VALUE level = rb_uint2num_inline (d->level);
+        rb_iv_set (arg, "@level", level);
+        break;
+      }
+
+    case MD_BLOCK_CODE:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cCodeBlock);
+        MD_BLOCK_CODE_DETAIL *d = detail;
+
+        VALUE info = rb_class_new_instance (0, NULL, rbm_cStringAttribute);
+        RTYPEDDATA_DATA (info) = &d->info;
+        rb_iv_set (arg, "@info", info);
+
+        VALUE lang = rb_class_new_instance (0, NULL, rbm_cStringAttribute);
+        RTYPEDDATA_DATA (lang) = &d->lang;
+        rb_iv_set (arg, "@lang", lang);
+
+        VALUE fence
+            = d->fence_char ? rb_str_new (&d->fence_char, 1) : RUBY_Qnil;
+        rb_iv_set (arg, "@fence_char", fence);
+        break;
+      }
+
+    case MD_BLOCK_HTML:
+      arg = rb_id2sym (rb_intern ("html"));
+      break;
+
+    case MD_BLOCK_P:
+      arg = rb_id2sym (rb_intern ("paragraph"));
+      break;
+
+    case MD_BLOCK_TABLE:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cTable);
+        MD_BLOCK_TABLE_DETAIL *d = detail;
+
+        VALUE col = rb_uint2num_inline (d->col_count);
+        rb_iv_set (arg, "@col_count", col);
+
+        VALUE head = rb_uint2num_inline (d->head_row_count);
+        rb_iv_set (arg, "@head_row_count", head);
+
+        VALUE body = rb_uint2num_inline (d->body_row_count);
+        rb_iv_set (arg, "@body_row_count", body);
+        break;
+      }
+
+    case MD_BLOCK_THEAD:
+      /* <thead> HTML table head element
+       * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/thead
+       */
+      arg = rb_id2sym (rb_intern ("table_head"));
+      break;
+
+    case MD_BLOCK_TBODY:
+      arg = rb_id2sym (rb_intern ("table_body"));
+      break;
+
+    case MD_BLOCK_TR:
+      arg = rb_id2sym (rb_intern ("table_row"));
+      break;
+
+    case MD_BLOCK_TH:
+      arg = rb_class_new_instance (0, NULL, rbm_cTableHeader);
+      goto table_data;
+
+    case MD_BLOCK_TD:
+      arg = rb_class_new_instance (0, NULL, rbm_cTableData);
+      goto table_data;
+
+    table_data:
+      {
+        VALUE align = RUBY_Qnil;
+        MD_BLOCK_TD_DETAIL *d = detail;
+        switch (d->align)
+          {
+          case MD_ALIGN_DEFAULT:
+            break;
+
+          case MD_ALIGN_LEFT:
+            {
+              align = rb_id2sym (rb_intern ("left"));
+              break;
+            }
+
+          case MD_ALIGN_CENTER:
+            {
+              align = rb_id2sym (rb_intern ("center"));
+              break;
+            }
+
+          case MD_ALIGN_RIGHT:
+            {
+              align = rb_id2sym (rb_intern ("right"));
+              break;
+            }
+          }
+
+        rb_iv_set (arg, "@align", align);
+        break;
+      }
+    }
+
+  VALUE args = rb_ary_new ();
+  rb_ary_push (args, arg);
+  return args;
+}
+
+static int
+rbm_callback_enter_block (MD_BLOCKTYPE type, void *detail, void *userdata)
+{
+  struct rbm_cParser *p = userdata;
+  if (!p->on_enter_block)
+    return 0;
+  VALUE args = rbm_callback_block_arguments (type, detail);
+  rb_proc_call (p->on_enter_block, args);
+  return 0;
+}
+
+static int
+rbm_callback_leave_block (MD_BLOCKTYPE type, void *detail, void *userdata)
+{
+  struct rbm_cParser *p = userdata;
+  if (!p->on_leave_block)
+    return 0;
+  VALUE args = rbm_callback_block_arguments (type, detail);
+  rb_proc_call (p->on_leave_block, args);
+  return 0;
+}
+
+static VALUE
+rbm_callback_span_arguments (MD_SPANTYPE type, void *detail)
+{
+  VALUE arg;
+  switch (type)
+    {
+    case MD_SPAN_EM:
+      arg = rb_id2sym (rb_intern ("emphasis"));
+      break;
+
+    case MD_SPAN_STRONG:
+      arg = rb_id2sym (rb_intern ("strong"));
+      break;
+
+    case MD_SPAN_A:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cAnchor);
+
+        MD_SPAN_A_DETAIL *d = detail;
+
+        VALUE href = rb_class_new_instance (0, NULL, rbm_cStringAttribute);
+        RTYPEDDATA_DATA (href) = &d->href;
+        rb_iv_set (arg, "@href", href);
+
+        VALUE title = rb_class_new_instance (0, NULL, rbm_cStringAttribute);
+        RTYPEDDATA_DATA (title) = &d->title;
+        rb_iv_set (arg, "@title", title);
+
+        VALUE autolink = d->is_autolink ? RUBY_Qtrue : RUBY_Qfalse;
+        rb_iv_set (arg, "@autolink", autolink);
+        break;
+      }
+
+    case MD_SPAN_IMG:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cImage);
+
+        MD_SPAN_IMG_DETAIL *d = detail;
+
+        VALUE src = rb_class_new_instance (0, NULL, rbm_cStringAttribute);
+        RTYPEDDATA_DATA (src) = &d->src;
+        rb_iv_set (arg, "@src", src);
+
+        VALUE title = rb_class_new_instance (0, NULL, rbm_cStringAttribute);
+        RTYPEDDATA_DATA (title) = &d->title;
+        rb_iv_set (arg, "@title", title);
+        break;
+      }
+
+    case MD_SPAN_CODE:
+      arg = rb_id2sym (rb_intern ("code"));
+      break;
+
+    case MD_SPAN_DEL:
+      /* https://github.github.com/gfm/#strikethrough-extension- */
+      arg = rb_id2sym (rb_intern ("strikethrough"));
+      break;
+
+    case MD_SPAN_LATEXMATH:
+      arg = rb_id2sym (rb_intern ("inline_latex_math"));
+      break;
+
+    case MD_SPAN_LATEXMATH_DISPLAY:
+      arg = rb_id2sym (rb_intern ("display_latex_math"));
+      break;
+
+    case MD_SPAN_WIKILINK:
+      {
+        arg = rb_class_new_instance (0, NULL, rbm_cWikiLink);
+
+        MD_SPAN_WIKILINK_DETAIL *d = detail;
+
+        VALUE target = rb_class_new_instance (0, NULL, rbm_cStringAttribute);
+        RTYPEDDATA_DATA (target) = &d->target;
+        rb_iv_set (arg, "@target", target);
+        break;
+      }
+
+    case MD_SPAN_U:
+      arg = rb_id2sym (rb_intern ("underline"));
+      break;
+    }
+
+  VALUE args = rb_ary_new ();
+  rb_ary_push (args, arg);
+  return args;
+}
+
+static int
+rbm_callback_enter_span (MD_SPANTYPE type, void *detail, void *userdata)
+{
+  struct rbm_cParser *p = userdata;
+  if (!p->on_enter_span)
+    return 0;
+  VALUE args = rbm_callback_span_arguments (type, detail);
+  rb_proc_call (p->on_enter_span, args);
+  return 0;
+}
+
+static int
+rbm_callback_leave_span (MD_SPANTYPE type, void *detail, void *userdata)
+{
+  struct rbm_cParser *p = userdata;
+  if (!p->on_leave_span)
+    return 0;
+  VALUE args = rbm_callback_span_arguments (type, detail);
+  rb_proc_call (p->on_leave_span, args);
+  return 0;
+}
+
+static int
+rbm_callback_text (MD_TEXTTYPE type, const MD_CHAR *text, MD_SIZE size,
+                   void *userdata)
+{
+  struct rbm_cParser *p = userdata;
+  if (!p->on_text)
+    return 0;
+  VALUE string = rb_str_new (text, size);
+  VALUE klass = rbm_get_text_class (type);
+  VALUE args = rb_ary_new ();
+  VALUE arg = rb_class_new_instance (0, NULL, klass);
+  rb_iv_set (arg, "@content", string);
+  rb_ary_push (args, arg);
+  rb_proc_call (p->on_text, args);
+  return 0;
+}
+
+static VALUE
+rbm_cParser_m_parse (VALUE self, VALUE source)
+{
+  char *text = rb_string_value_ptr (&source);
+  long size = RSTRING_LEN (source);
+  struct rbm_cParser *p = RTYPEDDATA_DATA (self);
+  MD_PARSER parser = { .flags = p->flags,
+                       .enter_block = rbm_callback_enter_block,
+                       .leave_block = rbm_callback_leave_block,
+                       .enter_span = rbm_callback_enter_span,
+                       .leave_span = rbm_callback_leave_span,
+                       .text = rbm_callback_text };
+  int result = md_parse (text, (MD_SIZE)size, &parser, p);
+  if (result == -1)
+    rb_raise (rbm_eError, "runtime error, such as memory fails");
+  if (result != 0)
+    rb_raise (rbm_eError, "parse failed");
+  return RUBY_Qnil;
+}
+
+struct rbm_markdown_to_html_userdata
+{
+  VALUE block;
+};
+
+static void
+rbm_markdown_to_html_callback (const MD_CHAR *input, MD_SIZE size,
+                               void *userdata)
+{
+  struct rbm_markdown_to_html_userdata *data = userdata;
+  VALUE text = rb_str_new (input, size);
+  VALUE args = rb_ary_new ();
+  rb_ary_push (args, text);
+  rb_proc_call (data->block, args);
+}
+
+static VALUE
+rbm_m_markdown_to_html (int argc, VALUE *argv, VALUE self)
+{
+  VALUE input, kwargs;
+  rb_scan_args (argc, argv, "1:", &input, &kwargs);
+
+  char *text = rb_string_value_ptr (&input);
+  long size = RSTRING_LEN (input);
+
+  ID kwargs_ids[] = { PARSER_FLAGS, rb_intern ("verbatim_entities"),
+                      rb_intern ("skip_utf8_bom"), rb_intern ("xhtml") };
+  VALUE kwargs_vals[sizeof (kwargs_ids) / sizeof (kwargs_ids[0])] = { 0 };
+  rb_get_kwargs (kwargs, kwargs_ids, 0,
+                 sizeof (kwargs_ids) / sizeof (kwargs_ids[0]), kwargs_vals);
+
+  unsigned pflags = rbm_get_parser_flags (kwargs_vals);
+
+  unsigned rflags = 0;
+
+  if (!RB_UNDEF_P (kwargs_vals[19]) || RB_TEST (kwargs_vals[19]))
+    rflags |= MD_HTML_FLAG_VERBATIM_ENTITIES;
+
+  if (!RB_UNDEF_P (kwargs_vals[20]) || RB_TEST (kwargs_vals[20]))
+    rflags |= MD_HTML_FLAG_SKIP_UTF8_BOM;
+
+  if (!RB_UNDEF_P (kwargs_vals[21]) || RB_TEST (kwargs_vals[21]))
+    rflags |= MD_HTML_FLAG_XHTML;
+
+  struct rbm_markdown_to_html_userdata *userdata
+      = ruby_xmalloc (sizeof (struct rbm_markdown_to_html_userdata));
+  *userdata
+      = (struct rbm_markdown_to_html_userdata){ .block = rb_block_proc () };
+  if (md_html (text, (MD_SIZE)size, rbm_markdown_to_html_callback, userdata,
+               pflags, rflags)
+      != 0)
+    {
+      ruby_xfree (userdata);
+      rb_raise (rbm_eError, "conversion fails");
+    }
+  ruby_xfree (userdata);
+  return RUBY_Qnil;
+}
+
+RUBY_FUNC_EXPORTED void
+Init_md4c (void)
+{
+  rb_mMD4C = rb_define_module ("MD4C");
+
+  rbm_cStringAttribute
+      = rb_define_class_under (rb_mMD4C, "StringAttribute", rb_cObject);
+  rb_define_alloc_func (rbm_cStringAttribute, rbm_cStringAttribute_alloc);
+  rb_define_method (rbm_cStringAttribute, "each", rbm_cStringAttribute_m_each,
+                    0);
+
+  rbm_cUnorderedList
+      = rb_define_class_under (rb_mMD4C, "UnorderedList", rb_cObject);
+  rbm_cOrderedList
+      = rb_define_class_under (rb_mMD4C, "OrderedList", rb_cObject);
+  rbm_cListItem = rb_define_class_under (rb_mMD4C, "ListItem", rb_cObject);
+  rbm_cHeading = rb_define_class_under (rb_mMD4C, "Heading", rb_cObject);
+  rbm_cCodeBlock = rb_define_class_under (rb_mMD4C, "CodeBlock", rb_cObject);
+  rbm_cTable = rb_define_class_under (rb_mMD4C, "Table", rb_cObject);
+  rbm_cTableHeader
+      = rb_define_class_under (rb_mMD4C, "TableHeader", rb_cObject);
+  rbm_cTableData = rb_define_class_under (rb_mMD4C, "TableData", rb_cObject);
+
+  rbm_cAnchor = rb_define_class_under (rb_mMD4C, "Anchor", rb_cObject);
+  rbm_cImage = rb_define_class_under (rb_mMD4C, "Image", rb_cObject);
+  rbm_cWikiLink = rb_define_class_under (rb_mMD4C, "WikiLink", rb_cObject);
+
+  rbm_cNormalText = rb_define_class_under (rb_mMD4C, "NormalText", rb_cObject);
+  rbm_cNullChar = rb_define_class_under (rb_mMD4C, "NullChar", rb_cObject);
+  rbm_cHardBreak = rb_define_class_under (rb_mMD4C, "HardBreak", rb_cObject);
+  rbm_cSoftBreak = rb_define_class_under (rb_mMD4C, "SoftBreak", rb_cObject);
+  rbm_cEntity = rb_define_class_under (rb_mMD4C, "Entity", rb_cObject);
+  rbm_cCodeText = rb_define_class_under (rb_mMD4C, "CodeText", rb_cObject);
+  rbm_cHTMLText = rb_define_class_under (rb_mMD4C, "HTMLText", rb_cObject);
+  rbm_cLaTeXMathText
+      = rb_define_class_under (rb_mMD4C, "LaTeXMathText", rb_cObject);
+
+  rbm_cParser = rb_define_class_under (rb_mMD4C, "Parser", rb_cObject);
+  rb_define_alloc_func (rbm_cParser, rbm_cParser_alloc);
+  rb_define_method (rbm_cParser, "initialize", rbm_cParser_m_initialize, -1);
+
+  rb_define_method (rbm_cParser, "on_enter_block",
+                    rbm_cParser_m_on_enter_block, 0);
+  rb_define_method (rbm_cParser, "on_leave_block",
+                    rbm_cParser_m_on_leave_block, 0);
+  rb_define_method (rbm_cParser, "on_enter_span", rbm_cParser_m_on_enter_span,
+                    0);
+  rb_define_method (rbm_cParser, "on_leave_span", rbm_cParser_m_on_leave_span,
+                    0);
+  rb_define_method (rbm_cParser, "on_text", rbm_cParser_m_on_text, 0);
+
+  rb_define_method (rbm_cParser, "parse", rbm_cParser_m_parse, 1);
+
+  rb_define_module_function (rb_mMD4C, "markdown_to_html",
+                             rbm_m_markdown_to_html, -1);
+
+  rbm_eError = rb_define_class_under (rb_mMD4C, "Error", rb_eStandardError);
+}