parkdown 1.4.28

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 93f0d59c055327369415594462a78eb9c530ac1cb53d584c3cb2cc643022a64b
+  data.tar.gz: d0abf40bc764cae07358cabe567d2c6d9580fa263b46b47cccfabb56ede6ac05
+SHA512:
+  metadata.gz: b6a6198c506213e9ce7cc205dbb8e29d8e1f43182bfc95d4cba53f67530856174ec356719ae5d9615f58da12ceb1f6b1d93bb7f7b0b90d650af8b1df41ef082d
+  data.tar.gz: f5ae8b63d80d32e27705c12cde4ee1981980f3ee20c2f6373c2c185cd7c1b89ae1fe48465c62a1f9a20d105f23fc46cf91b06d96a54624d7fad7ac28be82df66

data/LICENSE

@@ -0,0 +1,68 @@
+Ruby Markdown Extension, implemented using peg-markdown
+Copyright (c) 2011-2014 Ricardo Wurmus
+Copyright (c) 2008 Ryan Tomayko
+markdown in c, implemented using PEG grammar
+Copyright (c) 2008 John MacFarlane
+
+Parkdown is released under the GPL
+
+The GPL
+
+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 2 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, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+peg-0.1.4 (included for convenience - http://piumarta.com/software/peg/)
+
+Copyright (c) 2007 by Ian Piumarta
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the 'Software'),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, provided that the above copyright notice(s) and this
+permission notice appear in all copies of the Software.  Acknowledgement
+of the use of this Software in supporting documentation would be
+appreciated but is not required.
+
+THE SOFTWARE IS PROVIDED 'AS IS'.  USE ENTIRELY AT YOUR OWN RISK.
+
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+my_getopt (included for convenience - http://www.geocities.com/bsittler/) 
+
+Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,86 @@
+Parkdown --- Ruby Markdown library
+==================================
+
+Parkdown is a Ruby extension library around [my fork][1] of
+[John MacFarlane's fast implementation][2] of Markdown in C.  This
+extension library is a fork of Ryan Tomayko's [rpeg-markdown][3]
+library.  The main difference between Ryan's library and Parkdown is
+the underlying parser.  Ryan's library uses an outdated version of
+John MacFarlane's peg-markdown, while Parkdown uses the parser
+generated from [my heavily extended Markdown grammar][4].
+
+[1]: https://github.com/rekado/peg-markdown/
+[2]: https://github.com/jgm/peg-markdown/
+[3]: https://github.com/rtomayko/rpeg-markdown
+[4]: https://github.com/rekado/peg-markdown/blob/master/markdown_parser.leg
+
+Synopsis
+--------
+
+    >> require 'markdown'
+    >> puts Markdown.new('Hello, world.').to_html
+    <p>Hello, world.</p>
+
+    >> puts Markdown.new('_Hello World!_', :smart, :filter_html).to_html
+    <p><em>Hello World!</em></p>
+
+    >> puts Markdown.new('_Hello World!_').to_latex
+    \emph{Hello World!}
+
+    >> puts Markdown.new('_Hello World!_').to_groff_mm
+    .P
+    \fIHello world!\fR
+
+
+Extensions
+----------
+
+Parkdown comes with the following non-standard extensions that are not
+found in the libraries its originally based on:
+
+- HTML5 video embedding: `%[caption](file-url.ogv alternative.mp4)`
+- HTML5 audio embedding: `~[title](file-url.ogg alternative.mp3)`
+- autolink: turns plain URLs (not wrapped in angled brackets) into
+  clickable links
+- strike-through: `I owe you ~~ten~~ twenty coins.`
+- image filtering: renders images as regular links
+- hard wrap: translate simple line breaks into HTML line breaks
+- code blocks: wrap a block in `~~~` to render it as a code block
+- hashtags: wraps any term starting with `#` in `<span rel="hashtag">...</span>`
+- usernames: wraps any name starting with `@` in `<span rel="username">...</span>`
+- spoilers: a block prefixed with `?>` will be wrapped in a `<div class="spoilers">`.
+  Use CSS and JS to hide and show the block as needed.
+
+
+Hacking
+-------
+
+The hard work of rendering some plain text syntax to
+HTML/LaTeX/ODF/etc. is done by the parser that is generated from the
+grammar in peg-markdown.  To implement custom extensions, fork
+peg-markdown and extend the grammar.  Then update the peg-markdown
+submodule in your fork of parkdown and expose the extension in the
+Ruby library.  Use the rake task `rake gather` to build the parser
+from the grammar in the `peg-markdown/` directory and collect the
+files in `ext/`.  Then build the extension with `rake build`.
+
+Patches are happily accepted via pull requests or email.
+
+
+Installation
+------------
+
+This library requires a recent version of glib2. All modern GNU
+userland systems should be fine.
+
+Install from GEM:
+
+    $ sudo gem install parkdown
+
+
+COPYING
+-------
+
+The peg-markdown sources are licensed under the GPL and Parkdown
+adopts this license (just as the original rpeg-markdown did).  See the
+file LICENSE included with this distribution for more information.

data/Rakefile

@@ -0,0 +1,170 @@
+require 'rake/clean'
+require 'rake/packagetask'
+require 'rubygems/package_task'
+
+task :default => :test
+
+DLEXT = RbConfig::CONFIG['DLEXT']
+VERS = '1.4.26'
+
+spec =
+  Gem::Specification.new do |s|
+    s.name              = "parkdown"
+    s.version           = VERS
+    s.summary           = "Fast Markdown implementation"
+    s.files             = FileList[
+                            'README.markdown','LICENSE','Rakefile',
+                            '{lib,ext,test}/**.rb','ext/*.{c,h}',
+                            'test/MarkdownTest*/**/*',
+                            'bin/parkdown'
+                          ]
+    s.bindir            = 'bin'
+    s.executables       << 'parkdown'
+    s.require_path      = 'lib'
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = ['LICENSE']
+    s.test_files        = FileList['test/markdown_test.rb']
+    s.extensions        = ['ext/extconf.rb']
+
+    s.author            = 'rekado'
+    s.email             = 'spam@elephly.net'
+    s.homepage          = 'http://github.com/rekado/parkdown'
+    s.rubyforge_project = 'wink'
+  end
+
+  Gem::PackageTask.new(spec) do |p|
+    p.gem_spec = spec
+    p.need_tar_gz = true
+    p.need_tar = false
+    p.need_zip = false
+  end
+
+namespace :submodule do
+  desc 'Init the peg-markdown submodule'
+  task :init do |t|
+    unless File.exist? 'peg-markdown/markdown.c'
+      rm_rf 'peg-markdown'
+      sh 'git submodule init peg-markdown'
+      sh 'git submodule update peg-markdown'
+    end
+  end
+
+  desc 'Update the peg-markdown submodule'
+  task :update => :init do
+    sh 'git submodule update peg-markdown' unless File.symlink?('peg-markdown')
+  end
+
+  file 'peg-markdown/markdown.c' do
+    Rake::Task['submodule:init'].invoke
+  end
+  task :exist => 'peg-markdown/markdown.c'
+end
+
+desc 'Gather required peg-markdown sources into extension directory'
+task :gather => 'submodule:exist' do |t|
+  sh 'cd peg-markdown && make markdown_parser.c'
+  files =
+    FileList[
+      'peg-markdown/markdown_{peg.h,parser.c,output.c,lib.c,lib.h}',
+      'peg-markdown/{utility,parsing}_functions.c',
+      'peg-markdown/{utility,parsing}_functions.h'
+    ]
+  cp files, 'ext/',
+    :preserve => true,
+    :verbose => true
+end
+
+file 'ext/Makefile' => FileList['ext/{extconf.rb,*.c,*.h,*.rb}'] do
+  chdir('ext') { ruby 'extconf.rb' }
+end
+CLEAN.include 'ext/Makefile'
+
+file "ext/peg_markdown.#{DLEXT}" => FileList['ext/Makefile', 'ext/*.{c,h,rb}'] do |f|
+  sh 'cd ext && make'
+end
+CLEAN.include 'ext/*.{o,bundle,so}'
+
+file "lib/peg_markdown.#{DLEXT}" => "ext/peg_markdown.#{DLEXT}" do |f|
+  cp f.prerequisites, "lib/", :preserve => true
+end
+CLEAN.include "lib/*.{so,bundle}"
+
+desc 'Build the peg_markdown extension'
+task :build => "lib/peg_markdown.#{DLEXT}"
+
+desc 'Run unit and conformance tests'
+task :test => [ 'test:unit', 'test:conformance' ]
+
+desc 'Run unit tests'
+task 'test:unit' => [:build] do |t|
+  ruby 'test/markdown_test.rb'
+end
+
+desc "Run conformance tests (MARKDOWN_TEST_VER=#{ENV['MARKDOWN_TEST_VER'] ||= '1.0.3'})"
+task 'test:conformance' => [:build] do |t|
+  script = "#{pwd}/bin/parkdown"
+  test_version = ENV['MARKDOWN_TEST_VER']
+  chdir("test/MarkdownTest_#{test_version}") do
+    sh "./MarkdownTest.pl --script='#{script}' --tidy"
+  end
+end
+
+desc 'Run version 1.0 conformance suite'
+task 'test:conformance:1.0' => [:build] do
+  ENV['MARKDOWN_TEST_VER'] = '1.0'
+  Rake::Task['test:conformance'].invoke
+end
+
+desc 'Run 1.0.3 conformance suite'
+task 'test:conformance:1.0.3' => [:build] do |t|
+  ENV['MARKDOWN_TEST_VER'] = '1.0.3'
+  Rake::Task['test:conformance'].invoke
+end
+
+desc 'Run unit and conformance tests'
+task :test => %w[test:unit test:conformance]
+
+desc 'Run benchmarks'
+task :benchmark => :build do |t|
+  $:.unshift 'lib'
+  load 'test/benchmark.rb'
+end
+
+desc "See how much memory we're losing"
+task 'test:mem' => %w[submodule:exist build] do |t|
+  $: << File.join(File.dirname(__FILE__), "lib")
+  require 'markdown'
+  FileList['test/mem.txt', 'peg-markdown/MarkdownTest_1.0.3/Tests/*.text'].each do |file|
+    printf "%s: \n", file
+    markdown = Markdown.new(File.read(file))
+    iterations = (ENV['N'] || 100).to_i
+    total, growth = [], []
+    iterations.times do |i|
+      start = Time.now
+      GC.start
+      markdown.to_html
+      duration = Time.now - start
+      GC.start
+      total << `ps -o rss= -p #{Process.pid}`.to_i
+      next if i == 0
+      growth << (total.last - (total[-2] || 0))
+      # puts "%03d: %06.02f ms / %dK used / %dK growth" % [ i, duration, total.last, growth.last ]
+    end
+    average = growth.inject(0) { |sum,x| sum + x } / growth.length
+    printf "  %dK avg growth (per run) / %dK used (after %d runs)\n", average, total.last, iterations
+  end
+end
+
+# ==========================================================
+# Rubyforge
+# ==========================================================
+
+PKGNAME = "pkg/parkdown-#{VERS}"
+
+desc 'Publish new release to rubyforge'
+task :release => [ "#{PKGNAME}.gem", "#{PKGNAME}.tar.gz" ] do |t|
+  sh <<-end
+    rubyforge add_release wink parkdown #{VERS} #{PKGNAME}.gem &&
+    rubyforge add_file    wink parkdown #{VERS} #{PKGNAME}.tar.gz
+  end
+end

data/bin/parkdown

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'markdown'
+rescue LoadError => boom
+  local_path = File.expand_path(File.dirname(__FILE__))
+  $: << "#{local_path}/../lib"
+  require 'markdown'
+end
+
+STDIN.reopen(ARGV[0], 'rb') if ARGV.any?
+markdown = Markdown.new(STDIN.read)
+STDOUT.write(markdown.to_html)

data/ext/extconf.h

@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif

data/ext/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+dir_config('peg_markdown')
+
+$objs = %w[markdown.o markdown_lib.o markdown_output.o markdown_parser.o parsing_functions.o utility_functions.o]
+
+if pkg_config = find_executable('pkg-config')
+  $CFLAGS = `#{pkg_config} --cflags glib-2.0`
+  $LDFLAGS = `#{pkg_config} --libs glib-2.0`
+else
+  fail "glib2 not found"
+end
+
+create_header
+create_makefile('peg_markdown')

data/ext/markdown.c

@@ -0,0 +1,104 @@
+#include "ruby.h"
+#include "markdown_lib.h"
+
+static VALUE rb_cMarkdown;
+
+static VALUE
+rb_markdown_to_html(int argc, VALUE *argv, VALUE self)
+{
+    /* grab char pointer to markdown input text */
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    Check_Type(text, T_STRING);
+    char * ptext = StringValuePtr(text);
+
+    /* flip extension bits */
+    int extensions = 0;
+    if ( rb_funcall(self, rb_intern("smart"), 0) == Qtrue )
+        extensions = extensions | EXT_SMART ;
+    if ( rb_funcall(self, rb_intern("notes"), 0) == Qtrue )
+        extensions = extensions | EXT_NOTES ;
+    if ( rb_funcall(self, rb_intern("filter_html"), 0) == Qtrue )
+        extensions = extensions | EXT_FILTER_HTML ;
+    if ( rb_funcall(self, rb_intern("filter_styles"), 0) == Qtrue )
+        extensions = extensions | EXT_FILTER_STYLES ;
+    if ( rb_funcall(self, rb_intern("strike"), 0) == Qtrue )
+        extensions = extensions | EXT_STRIKE ;
+    if ( rb_funcall(self, rb_intern("autolink"), 0) == Qtrue )
+        extensions = extensions | EXT_AUTOLINK ;
+    if ( rb_funcall(self, rb_intern("hard_wrap"), 0) == Qtrue )
+        extensions = extensions | EXT_HARD_WRAP ;
+    if ( rb_funcall(self, rb_intern("no_images"), 0) == Qtrue )
+        extensions = extensions | EXT_NO_IMAGES ;
+    if ( rb_funcall(self, rb_intern("media"), 0) == Qtrue )
+        extensions = extensions | EXT_MEDIA ;
+    if ( rb_funcall(self, rb_intern("codeblock"), 0) == Qtrue )
+        extensions = extensions | EXT_CODEBLOCK ;
+    if ( rb_funcall(self, rb_intern("hashtags"), 0) == Qtrue )
+        extensions = extensions | EXT_HASHTAGS ;
+    if ( rb_funcall(self, rb_intern("usernames"), 0) == Qtrue )
+        extensions = extensions | EXT_USERNAMES ;
+    if ( rb_funcall(self, rb_intern("spoilerblock"), 0) == Qtrue )
+        extensions = extensions | EXT_SPOILERBLOCK ;
+
+    char *html = markdown_to_string(ptext, extensions, HTML_FORMAT);
+    VALUE result = rb_str_new2(html);
+    free(html);
+
+    return result;
+}
+
+static VALUE
+rb_markdown_to_latex(int argc, VALUE *argv, VALUE self)
+{
+    /* grab char pointer to markdown input text */
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    Check_Type(text, T_STRING);
+    char * ptext = StringValuePtr(text);
+
+    /* flip extension bits - note that defaults are different than
+     * for HTML */
+    int extensions = EXT_SMART | EXT_NOTES | EXT_FILTER_HTML | EXT_FILTER_STYLES;
+    if ( rb_funcall(self, rb_intern("smart"), 0) == Qfalse )
+        extensions = extensions & ~ EXT_SMART ;
+    if ( rb_funcall(self, rb_intern("notes"), 0) == Qfalse )
+        extensions = extensions & ~ EXT_NOTES ;
+
+    char *latex = markdown_to_string(ptext, extensions, LATEX_FORMAT);
+    VALUE result = rb_str_new2(latex);
+    free(latex);
+
+    return result;
+}
+
+static VALUE
+rb_markdown_to_groff_mm(int argc, VALUE *argv, VALUE self)
+{
+    /* grab char pointer to markdown input text */
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    Check_Type(text, T_STRING);
+    char * ptext = StringValuePtr(text);
+
+    /* flip extension bits - note that defaults are different than
+     * for HTML */
+    int extensions = EXT_SMART | EXT_NOTES | EXT_FILTER_HTML | EXT_FILTER_STYLES;
+    if ( rb_funcall(self, rb_intern("smart"), 0) == Qfalse )
+        extensions = extensions & ~ EXT_SMART ;
+    if ( rb_funcall(self, rb_intern("notes"), 0) == Qfalse )
+        extensions = extensions & ~ EXT_NOTES ;
+
+    char *groff = markdown_to_string(ptext, extensions, GROFF_MM_FORMAT);
+    VALUE result = rb_str_new2(groff);
+    free(groff);
+
+    return result;
+}
+
+void Init_peg_markdown()
+{
+    rb_cMarkdown = rb_define_class("PEGMarkdown", rb_cObject);
+    rb_define_method(rb_cMarkdown, "to_html", rb_markdown_to_html, -1);
+    rb_define_method(rb_cMarkdown, "to_latex", rb_markdown_to_latex, -1);
+    rb_define_method(rb_cMarkdown, "to_groff_mm", rb_markdown_to_groff_mm, -1);
+}
+
+// vim: ts=4 sw=4

data/ext/markdown_lib.c

@@ -0,0 +1,186 @@
+/**********************************************************************
+
+  markdown_lib.c - markdown in C using a PEG grammar.
+  (c) 2008 John MacFarlane (jgm at berkeley dot edu).
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License or the MIT
+  license.  See LICENSE for details.
+
+  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.
+
+ ***********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "markdown_peg.h"
+
+#define TABSTOP 4
+
+/* preformat_text - allocate and copy text buffer while
+ * performing tab expansion. */
+static GString *preformat_text(char *text) {
+    GString *buf;
+    char next_char;
+    int charstotab;
+
+    int len = 0;
+
+    buf = g_string_new("");
+
+    charstotab = TABSTOP;
+    while ((next_char = *text++) != '\0') {
+        switch (next_char) {
+        case '\t':
+            while (charstotab > 0)
+                g_string_append_c(buf, ' '), len++, charstotab--;
+            break;
+        case '\n':
+            g_string_append_c(buf, '\n'), len++, charstotab = TABSTOP;
+            break;
+        default:
+            g_string_append_c(buf, next_char), len++, charstotab--;
+        }
+        if (charstotab == 0)
+            charstotab = TABSTOP;
+    }
+    g_string_append(buf, "\n\n");
+    return(buf);
+}
+
+/* print_tree - print tree of elements, for debugging only. */
+static void print_tree(element * elt, int indent) {
+    int i;
+    char * key;
+    while (elt != NULL) {
+        for (i = 0; i < indent; i++)
+            fputc(' ', stderr);
+        switch (elt->key) {
+            case LIST:               key = "LIST"; break;
+            case RAW:                key = "RAW"; break;
+            case SPACE:              key = "SPACE"; break;
+            case LINEBREAK:          key = "LINEBREAK"; break;
+            case ELLIPSIS:           key = "ELLIPSIS"; break;
+            case EMDASH:             key = "EMDASH"; break;
+            case ENDASH:             key = "ENDASH"; break;
+            case APOSTROPHE:         key = "APOSTROPHE"; break;
+            case SINGLEQUOTED:       key = "SINGLEQUOTED"; break;
+            case DOUBLEQUOTED:       key = "DOUBLEQUOTED"; break;
+            case STR:                key = "STR"; break;
+            case LINK:               key = "LINK"; break;
+            case IMAGE:              key = "IMAGE"; break;
+            case AUDIO:              key = "AUDIO"; break;
+            case VIDEO:              key = "VIDEO"; break;
+            case CODE:               key = "CODE"; break;
+            case HTML:               key = "HTML"; break;
+            case EMPH:               key = "EMPH"; break;
+            case STRONG:             key = "STRONG"; break;
+            case PLAIN:              key = "PLAIN"; break;
+            case PARA:               key = "PARA"; break;
+            case LISTITEM:           key = "LISTITEM"; break;
+            case BULLETLIST:         key = "BULLETLIST"; break;
+            case ORDEREDLIST:        key = "ORDEREDLIST"; break;
+            case H1:                 key = "H1"; break;
+            case H2:                 key = "H2"; break;
+            case H3:                 key = "H3"; break;
+            case H4:                 key = "H4"; break;
+            case H5:                 key = "H5"; break;
+            case H6:                 key = "H6"; break;
+            case BLOCKQUOTE:         key = "BLOCKQUOTE"; break;
+            case SPOILERBLOCK:       key = "SPOILERBLOCK"; break;
+            case VERBATIM:           key = "VERBATIM"; break;
+            case HTMLBLOCK:          key = "HTMLBLOCK"; break;
+            case HRULE:              key = "HRULE"; break;
+            case REFERENCE:          key = "REFERENCE"; break;
+            case NOTE:               key = "NOTE"; break;
+            case HASHTAG:            key = "HASHTAG"; break;
+            case USERNAME:           key = "USERNAME"; break;
+            default:                 key = "?";
+        }
+        if ( elt->key == STR ) {
+            fprintf(stderr, "0x%p: %s   '%s'\n", (void *)elt, key, elt->contents.str);
+        } else {
+            fprintf(stderr, "0x%p: %s\n", (void *)elt, key);
+        }
+        if (elt->children)
+            print_tree(elt->children, indent + 4);
+        elt = elt->next;
+    }
+}
+
+/* process_raw_blocks - traverses an element list, replacing any RAW elements with
+ * the result of parsing them as markdown text, and recursing into the children
+ * of parent elements.  The result should be a tree of elements without any RAWs. */
+static element * process_raw_blocks(element *input, int extensions, element *references, element *notes) {
+    element *current = NULL;
+    element *last_child = NULL;
+    char *contents;
+    current = input;
+
+    while (current != NULL) {
+        if (current->key == RAW) {
+            /* \001 is used to indicate boundaries between nested lists when there
+             * is no blank line.  We split the string by \001 and parse
+             * each chunk separately. */
+            contents = strtok(current->contents.str, "\001");
+            current->key = LIST;
+            current->children = parse_markdown(contents, extensions, references, notes);
+            last_child = current->children;
+            while ((contents = strtok(NULL, "\001"))) {
+                while (last_child->next != NULL)
+                    last_child = last_child->next;
+                last_child->next = parse_markdown(contents, extensions, references, notes);
+            }
+            free(current->contents.str);
+            current->contents.str = NULL;
+        }
+        if (current->children != NULL)
+            current->children = process_raw_blocks(current->children, extensions, references, notes);
+        current = current->next;
+    }
+    return input;
+}
+
+/* markdown_to_gstring - convert markdown text to the output format specified.
+ * Returns a GString, which must be freed after use using g_string_free(). */
+GString * markdown_to_g_string(char *text, int extensions, int output_format) {
+    element *result;
+    element *references;
+    element *notes;
+    GString *formatted_text;
+    GString *out;
+    out = g_string_new("");
+
+    formatted_text = preformat_text(text);
+
+    references = parse_references(formatted_text->str, extensions);
+    notes = parse_notes(formatted_text->str, extensions, references);
+    result = parse_markdown(formatted_text->str, extensions, references, notes);
+
+    result = process_raw_blocks(result, extensions, references, notes);
+
+    g_string_free(formatted_text, TRUE);
+
+    print_element_list(out, result, output_format, extensions);
+
+    free_element_list(result);
+    free_element_list(references);
+    return out;
+}
+
+/* markdown_to_string - convert markdown text to the output format specified.
+ * Returns a null-terminated string, which must be freed after use. */
+char * markdown_to_string(char *text, int extensions, int output_format) {
+    GString *out;
+    char *char_out;
+    out = markdown_to_g_string(text, extensions, output_format);
+    char_out = out->str;
+    g_string_free(out, FALSE);
+    return char_out;
+}
+
+/* vim:set ts=4 sw=4: */