rpeg-markdown 0.1.0

data/LICENSE

@@ -0,0 +1,85 @@
+Ruby Markdown Extension, implemented using peg-markdown
+Copyright (c) 2008 Ryan Tomayko
+
+Released under 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
+
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+markdown in c, implemented using PEG grammar
+Copyright (c) 2008 John MacFarlane
+
+Released under 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

@@ -0,0 +1,14 @@
+Ruby peg-markdown Extension
+===========================
+
+The peg-markdown extension wraps John MacFarlane's C implementation of
+Markdown (see [peg-markdown][1]) in a Ruby extension.
+
+[1]: http://github.com/jgm/peg-markdown/ 
+   "Jon MacFarleane's peg-markdown project"
+
+### COPYING
+
+The peg-markdown sources are licensed under the GPL and the Ruby extension
+sources adopts this license. See the file LICENSE included with this
+distribution for more information.

data/Rakefile

@@ -0,0 +1,96 @@
+require 'rake/clean'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+DLEXT = Config::CONFIG['DLEXT']
+VERS = '0.1.0'
+
+spec =
+  Gem::Specification.new do |s|
+    s.name              = "rpeg-markdown"
+    s.version           = VERS
+    s.summary           = "Ruby extension library for peg-markdown"
+    s.files             = FileList['README','LICENSE','Rakefile','test.rb','{lib,ext}/**.rb','ext/*.{c,h}','bin/rpeg-markdown']
+    s.bindir            = 'bin'
+    s.executables       << 'rpeg-markdown'
+    s.require_path      = 'lib'
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = ['README', 'LICENSE']
+    s.test_files        = Dir['test.rb']
+    s.extensions        = ['ext/extconf.rb']
+
+    s.author            = 'Ryan Tomayko'
+    s.email             = 'r@tomayko.com'
+    s.homepage          = 'http://github.com/rtomayko/rpeg-markdown'
+    s.rubyforge_project = 'wink'
+  end
+
+  Rake::GemPackageTask.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
+
+  task :update => :init do
+    sh 'git submodule update peg-markdown'
+  end
+end
+
+desc 'Gather required peg-markdown sources into extension directory'
+task :gather => 'submodule:update' do |t|
+  sh 'cd peg-markdown && make markdown_parser.c'
+  cp FileList['peg-markdown/markdown_{peg.h,parser.c,output.c}'], 'ext/',
+    :preserve => true,
+    :verbose => true
+end
+CLOBBER.include 'ext/markdown_{peg.h,parser.c,output.c}'
+
+file 'ext/Makefile' => FileList['ext/{extconf.rb,*.c,*.h,*.rb}'] do
+  chdir('ext') { ruby 'extconf.rb' }
+end
+CLEAN.include 'ext/Makefile'
+
+file "ext/markdown.#{DLEXT}" => FileList['ext/Makefile', 'ext/*.{c,h,rb}'] do |f|
+  sh 'cd ext && make'
+end
+CLEAN.include 'ext/*.{o,bundle,so}'
+
+file "lib/markdown.#{DLEXT}" => "ext/markdown.#{DLEXT}" do |f|
+  cp f.prerequisites, "lib/", :preserve => true
+end
+
+desc 'Build the peg-markdown extension'
+task :build => "lib/markdown.#{DLEXT}"
+
+task 'test:unit' => [ :build ] do |t|
+  ruby 'test.rb'
+end
+
+task 'test:conformance' => [ 'submodule:update', :build ] do |t|
+  chdir('peg-markdown/MarkdownTest_1.0.3') do
+    sh "./MarkdownTest.pl --script=../../bin/rpeg-markdown --tidy"
+  end
+end
+
+
+
+# ==========================================================
+# Rubyforge
+# ==========================================================
+
+task 'release' => [ "pkg/rpeg-markdown-#{VERS}.gem", "pkg/rpeg-markdown-#{VERS}.tar.gz" ] do |t|
+  #  "pkg/rpeg-markdown-#{VERS}.gem",
+  #  "pkg/rpeg-markdown-#{VERS}.tar.gz"
+  sh "rubyforge add_release wink rpeg-markdown #{VERS} pkg/rpeg-markdown-#{VERS}.gem"
+end

data/bin/rpeg-markdown

@@ -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.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+$CFLAGS = "-Wall"
+
+dir_config('markdown')
+create_makefile('markdown')

data/ext/markdown.c

@@ -0,0 +1,90 @@
+#include "ruby.h"
+#include "markdown_peg.h"
+#include "markdown_buffer.h"
+
+static VALUE rb_cMarkdown;
+
+static ID id_text;
+static ID id_smart;
+static ID id_notes;
+
+#define TABSTOP 4
+#define INCREMENT 4096  /* size of chunks in which to allocate memory */
+
+static VALUE
+markdown_to_html(VALUE self)
+{
+  element parsed_input;
+  VALUE output_buffer;
+
+  char *inputbuf, *curchar;
+  int charstotab, buflength, maxlength;
+
+  /* grab char pointer to markdown input text */
+  VALUE text = rb_funcall(self, id_text, 0);
+  Check_Type(text, T_STRING);
+  char * ptext = StringValuePtr(text);
+
+  buflength = 0;
+  maxlength = RSTRING(text)->len >= INCREMENT ?
+    RSTRING(text)->len :
+    INCREMENT;
+  inputbuf = malloc(maxlength);
+  curchar = inputbuf;
+
+  charstotab = TABSTOP;
+  while ((*curchar = *ptext++) != '\0') {
+    switch (*curchar) {
+      case '\t':
+        while (charstotab > 0)
+          *curchar = ' ', curchar++, buflength++, charstotab--; 
+        break;
+      case '\n':
+        curchar++, buflength++, charstotab = TABSTOP;
+        break;
+      default:
+        curchar++, buflength++, charstotab--; 
+    }
+    if (charstotab == 0)
+      charstotab = TABSTOP;
+    if (buflength > maxlength - TABSTOP - 3) {
+      maxlength += INCREMENT;
+      inputbuf = realloc(inputbuf, maxlength);
+      curchar = inputbuf + buflength;
+      if (inputbuf == NULL) {
+        /* TODO: no memory */
+      }
+    }
+  }
+  *curchar++ = '\n';
+  *curchar++ = '\n';
+  *curchar   = '\0';
+  buflength+= 2;
+
+  /* flip extension bits */
+  int extensions = 0;
+  if ( rb_funcall(self, id_smart, 0) == Qtrue )
+    extensions = extensions | EXT_SMART ;
+  if ( rb_funcall(self, id_notes, 0) == Qtrue )
+    extensions = extensions | EXT_NOTES ;
+
+  /* parse markdown input into sematic element tree */
+  parsed_input = markdown(inputbuf, extensions);
+
+  /* allocate output buffer and generate output */
+  output_buffer = rb_markdown_buffer_init(buflength * 2);
+  print_element(parsed_input, HTML_FORMAT);
+  rb_markdown_buffer_free();
+  return output_buffer;
+}
+
+void Init_markdown()
+{
+  /* Initialize frequently used Symbols */
+  id_text = rb_intern("text");
+  id_smart = rb_intern("smart");
+  id_notes = rb_intern("notes");
+
+  rb_cMarkdown = rb_define_class("Markdown", rb_cObject);
+  rb_define_method(rb_cMarkdown, "to_html", markdown_to_html, 0);
+}

data/ext/markdown_buffer.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include "ruby.h"
+#include "markdown_buffer.h"
+
+static VALUE markdown_buffer;
+static int registered = 0;
+
+VALUE rb_markdown_buffer_init(long size) {
+  if ( registered != 1 ) {
+    rb_gc_register_address(&markdown_buffer);
+    registered = 1;
+  }
+  markdown_buffer = rb_str_buf_new(size);
+  return markdown_buffer;
+}
+
+void rb_markdown_buffer_free(void) {
+  markdown_buffer = Qnil;
+}
+
+int rb_markdown_buffer_printf(const char * format, ...)
+{
+  va_list args;
+  int length;
+  char * buf = NULL;
+
+  va_start(args, format);
+  length = vasprintf(&buf, format, args);
+  va_end(args);
+
+  if ( buf != NULL )  {
+    rb_str_buf_cat(markdown_buffer, buf, length);
+    free(buf);
+  } else {
+    /* TODO: handle out of memory condition */
+  }
+
+  return length;
+}
+
+char rb_markdown_buffer_putchar(char c)
+{
+  rb_str_buf_cat(markdown_buffer, &c, 1);
+  return c;
+}

data/ext/markdown_buffer.h

@@ -0,0 +1,6 @@
+#include "ruby.h"
+
+VALUE rb_markdown_buffer_init(long size);
+void rb_markdown_buffer_free(void);
+int rb_markdown_buffer_printf(const char * format, ...);
+char rb_markdown_buffer_putchar(char c);

data/ext/markdown_output.c

@@ -0,0 +1,769 @@
+/**********************************************************************
+
+  markdown_output.c - functions for printing Elements parsed by 
+                      markdown_peg.
+  (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 as published by
+  the Free Software Foundation; version 2 of the License.
+
+  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 <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "markdown_peg.h"
+
+/***********************************************************************/
+#include "markdown_buffer.h"
+#define printf  rb_markdown_buffer_printf
+#define putchar rb_markdown_buffer_putchar
+/***********************************************************************/
+
+/* TODO remove */
+static extensions = 0;
+
+static void print_html_string(char *str, bool obfuscate);
+static void print_html_element_list(element *list, bool obfuscate);
+static void print_html_element(element elt, bool obfuscate);
+static void print_latex_string(char *str);
+static void print_latex_element_list(element *list);
+static void print_latex_element(element elt);
+static void print_groff_string(char *str);
+static void print_groff_mm_element_list(element *list);
+static void print_groff_mm_element(element elt, int count);
+
+/**********************************************************************
+
+  Utility functions for printing
+
+ ***********************************************************************/
+
+static int padded = 2;      /* Number of newlines after last output.
+                               Starts at 2 so no newlines are needed at start.
+                               */
+
+static element *endnotes;   /* List of endnotes to print after main content. */
+static int notenumber = 0;  /* Number of footnote. */
+
+/* pad - add newlines if needed */
+static void pad(int num) {
+    while (num-- > padded)
+        printf("\n");;
+    padded = num;
+}
+
+/**********************************************************************
+
+  Functions for printing Elements as HTML
+
+ ***********************************************************************/
+
+/* print_html_string - print string, escaping for HTML  
+ * If obfuscate selected, convert characters to hex or decimal entities at random */
+static void print_html_string(char *str, bool obfuscate) {
+    while (*str != '\0') {
+        switch (*str) {
+        case '&':
+            printf("&amp;");;;
+            break;
+        case '<':
+            printf("&lt;");;;
+            break;
+        case '>':
+            printf("&gt;");;;
+            break;
+        case '"':
+            printf("&quot;");;;
+            break;
+        default:
+            if (obfuscate) {
+                if (rand() % 2 == 0)
+                    printf("&#%d;", (int) *str);
+                else
+                    printf("&#x%x;", (unsigned int) *str);
+            }
+            else
+                putchar(*str);
+        }
+    str++;
+    }
+}
+
+/* print_html_element_list - print a list of elements as HTML */
+static void print_html_element_list(element *list, bool obfuscate) {
+    while (list != NULL) {
+        print_html_element(*list, obfuscate);
+        list = list->next;
+    }
+}
+
+/* print_html_element - print an element as HTML */
+static void print_html_element(element elt, bool obfuscate) {
+    int lev;
+    char *contents;
+    switch (elt.key) {
+    case SPACE:
+        printf("%s", elt.contents.str);
+        break;
+    case LINEBREAK:
+        printf("<br/>");;;
+        break;
+    case STR:
+        print_html_string(elt.contents.str, obfuscate);
+        break;
+    case ELLIPSIS:
+        printf("&hellip;");;;
+        break;
+    case EMDASH:
+        printf("&mdash;");;;
+        break;
+    case ENDASH:
+        printf("&ndash;");;;
+        break;
+    case APOSTROPHE:
+        printf("&rsquo;");;;
+        break;
+    case SINGLEQUOTED:
+        printf("&lsquo;");;;
+        print_html_element_list(elt.children, obfuscate);
+        printf("&rsquo;");;;
+        break;
+    case DOUBLEQUOTED:
+        printf("&ldquo;");;;
+        print_html_element_list(elt.children, obfuscate);
+        printf("&rdquo;");;;
+        break;
+    case CODE:
+        printf("<code>");;;
+        print_html_string(elt.contents.str, obfuscate);
+        printf("</code>");;;
+        break;
+    case HTML:
+        printf("%s", elt.contents.str);
+        break;
+    case LINK:
+        if (strstr(elt.contents.link.url, "mailto:") == elt.contents.link.url)
+            obfuscate = true;  /* obfuscate mailto: links */
+        printf("<a href=\"");
+        print_html_string(elt.contents.link.url, obfuscate);
+        printf("\"");
+        if (strlen(elt.contents.link.title) > 0) {
+            printf(" title=\"");
+            print_html_string(elt.contents.link.title, obfuscate);
+            printf("\"");
+        }
+        printf(">");;;     
+        print_html_element_list(elt.contents.link.label, obfuscate);
+        printf("</a>");;;
+        break;
+    case IMAGE:
+        printf("<img src=\"");
+        print_html_string(elt.contents.link.url, obfuscate);
+        printf("\" alt=\"");
+        print_html_element_list(elt.contents.link.label, obfuscate);
+        printf("\"");
+        if (strlen(elt.contents.link.title) > 0) {
+            printf(" title=\"");
+            print_html_string(elt.contents.link.title, obfuscate);
+            printf("\"");
+        }
+        printf(" />");;;
+        break;
+    case EMPH:
+        printf("<em>");;;
+        print_html_element_list(elt.children, obfuscate);
+        printf("</em>");;;
+        break;
+    case STRONG:
+        printf("<strong>");;;
+        print_html_element_list(elt.children, obfuscate);
+        printf("</strong>");;;
+        break;
+    case LIST:
+        print_html_element_list(elt.children, obfuscate);
+        break;
+    case 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(elt.contents.str, "\001");
+        print_html_element(markdown(contents, extensions), obfuscate);
+        while ((contents = strtok(NULL, "\001")))
+            print_html_element(markdown(contents, extensions), obfuscate);
+        break;
+    case H1: case H2: case H3: case H4: case H5: case H6:
+        lev = elt.key - H1 + 1;  /* assumes H1 ... H6 are in order */
+        pad(2);
+        printf("<h%1d>", lev);
+        print_html_element_list(elt.children, obfuscate);
+        printf("</h%1d>", lev);
+        padded = 0;
+        break;
+    case PLAIN:
+        pad(1);
+        print_html_element_list(elt.children, obfuscate);
+        padded = 0;
+        break;
+    case PARA:
+        pad(2);
+        printf("<p>");;;
+        print_html_element_list(elt.children, obfuscate);
+        printf("</p>");;;
+        padded = 0;
+        break;
+    case HRULE:
+        pad(2);
+        printf("<hr />");;;
+        padded = 0;
+        break;
+    case HTMLBLOCK:
+        pad(2);
+        printf("%s", elt.contents.str);
+        padded = 0;
+        break;
+    case VERBATIM:
+        pad(2);
+        printf("%s", "<pre><code>");
+        print_html_string(elt.contents.str, obfuscate);
+        printf("%s", "</code></pre>");
+        padded = 0;
+        break;
+    case BULLETLIST:
+        pad(2);
+        printf("%s", "<ul>");
+        padded = 0;
+        print_html_element_list(elt.children, obfuscate);
+        pad(1);
+        printf("%s", "</ul>");
+        padded = 0;
+        break;
+    case ORDEREDLIST:
+        pad(2);
+        printf("%s", "<ol>");
+        padded = 0;
+        print_html_element_list(elt.children, obfuscate);
+        pad(1);
+        printf("</ol>");;;
+        padded = 0;
+        break;
+    case LISTITEM:
+        pad(1);
+        printf("<li>");;;
+        padded = 2;
+        print_html_element_list(elt.children, obfuscate);
+        printf("</li>");;;
+        padded = 0;
+        break;
+    case BLOCKQUOTE:
+        pad(2);
+        printf("<blockquote>\n");;;
+        padded = 2;
+        print_html_element_list(elt.children, obfuscate);
+        pad(1);
+        printf("</blockquote>");;;
+        padded = 0;
+        break;
+    case REFERENCE:
+        /* Nonprinting */
+        break;
+    case NOTE:
+        /* if contents.str == 0, then print note; else ignore, since this
+         * is a note block that has been incorporated into the notes list */
+        if (elt.contents.str == 0) {
+            endnotes = cons(elt, endnotes);
+            ++notenumber;
+            printf("<a class=\"noteref\" id=\"fnref%d\" href=\"#fn%d\" title=\"Jump to note %d\">[%d]</a>", 
+                notenumber, notenumber, notenumber, notenumber);
+        }
+        break;
+    default: 
+        fprintf(stderr, "print_html_element encountered unknown element key = %d\n", elt.key); 
+        exit(EXIT_FAILURE);
+    }
+}
+
+static void print_html_endnotes(void) {
+    int counter = 0;
+    if (endnotes == NULL) {
+        return;
+    }
+    printf("<hr/>\n<ol id=\"notes\">");
+    endnotes = reverse(endnotes);
+    while (endnotes != NULL) {
+        counter++;
+        pad(1);
+        printf("<li id=\"fn%d\">\n", counter);
+        padded = 2;
+        print_html_element_list(endnotes->children, false);
+        printf(" <a href=\"#fnref%d\" title=\"Jump back to reference\">[back]</a>", counter);
+        pad(1);
+        printf("</li>");;
+        endnotes = endnotes->next;
+    }
+    pad(1);
+    printf("</ol>");;;
+}
+
+/**********************************************************************
+
+  Functions for printing Elements as LaTeX
+
+ ***********************************************************************/
+
+/* print_latex_string - print string, escaping for LaTeX */
+static void print_latex_string(char *str) {
+    while (*str != '\0') {
+        switch (*str) {
+          case '{': case '}': case '$': case '%':
+          case '&': case '_': case '#':
+            printf("\\%c", *str);
+            break;
+        case '^':
+            printf("\\^{}");;;
+            break;
+        case '\\':
+            printf("\\textbackslash{}");;;
+            break;
+        case '~':
+            printf("\\ensuremath{\\sim}");;;
+            break;
+        case '|':
+            printf("\\textbar{}");;;
+            break;
+        case '<':
+            printf("\\textless{}");;;
+            break;
+        case '>':
+            printf("\\textgreater{}");;;
+            break;
+        default:
+            putchar(*str);
+        }
+    str++;
+    }
+}
+
+/* print_latex_element_list - print a list of elements as LaTeX */
+static void print_latex_element_list(element *list) {
+    while (list != NULL) {
+        print_latex_element(*list);
+        list = list->next;
+    }
+}
+
+/* print_latex_element - print an element as LaTeX */
+static void print_latex_element(element elt) {
+    int lev;
+    int i;
+    char *contents;
+    switch (elt.key) {
+    case SPACE:
+        printf("%s", elt.contents.str);
+        break;
+    case LINEBREAK:
+        printf("\\\\\n");;;
+        break;
+    case STR:
+        print_latex_string(elt.contents.str);
+        break;
+    case ELLIPSIS:
+        printf("\\ldots{}");;;
+        break;
+    case EMDASH: 
+        printf("---");;;
+        break;
+    case ENDASH: 
+        printf("--");;;
+        break;
+    case APOSTROPHE:
+        printf("'");;;
+        break;
+    case SINGLEQUOTED:
+        printf("`");;;
+        print_latex_element_list(elt.children);
+        printf("'");;;
+        break;
+    case DOUBLEQUOTED:
+        printf("``");;;
+        print_latex_element_list(elt.children);
+        printf("''");;;
+        break;
+    case CODE:
+        printf("\\texttt{");;;
+        print_latex_string(elt.contents.str);
+        printf("}");;;
+        break;
+    case HTML:
+        /* don't print HTML */
+        break;
+    case LINK:
+        printf("\\href{%s}{", elt.contents.link.url);
+        print_latex_element_list(elt.contents.link.label);
+        printf("}");;;
+        break;
+    case IMAGE:
+        printf("\\includegraphics{%s}", elt.contents.link.url);
+        break;
+    case EMPH:
+        printf("\\emph{");;;
+        print_latex_element_list(elt.children);
+        printf("}");;;
+        break;
+    case STRONG:
+        printf("\\textbf{");;;
+        print_latex_element_list(elt.children);
+        printf("}");;;
+        break;
+    case LIST:
+        print_latex_element_list(elt.children);
+        break;
+    case 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(elt.contents.str, "\001");
+        print_latex_element(markdown(contents, extensions));
+        while ((contents = strtok(NULL, "\001")))
+            print_latex_element(markdown(contents, extensions));
+        break;
+    case H1: case H2: case H3:
+        pad(2);
+        lev = elt.key - H1 + 1;  /* assumes H1 ... H6 are in order */
+        printf("\\");;;
+        for (i = elt.key; i > H1; i--)
+            printf("sub");;;
+        printf("section{");;;
+        print_latex_element_list(elt.children);
+        printf("}");;;
+        padded = 0;
+        break;
+    case H4: case H5: case H6:
+        pad(2);
+        printf("\\noindent\\textbf{");;;
+        print_latex_element_list(elt.children);
+        printf("}");;;
+        padded = 0;
+        break;
+    case PLAIN:
+        pad(1);
+        print_latex_element_list(elt.children);
+        padded = 0;
+        break;
+    case PARA:
+        pad(2);
+        print_latex_element_list(elt.children);
+        padded = 0;
+        break;
+    case HRULE:
+        pad(2);
+        printf("\\begin{center}\\rule{3in}{0.4pt}\\end{center}\n");;;
+        padded = 0;
+        break;
+    case HTMLBLOCK:
+        /* don't print HTML block */
+        break;
+    case VERBATIM:
+        pad(1);
+        printf("\\begin{verbatim}\n");;;
+        print_latex_string(elt.contents.str);
+        printf("\n\\end{verbatim}");;;
+        padded = 0;
+        break;
+    case BULLETLIST:
+        pad(1);
+        printf("\\begin{itemize}");;;
+        padded = 0;
+        print_latex_element_list(elt.children);
+        pad(1);
+        printf("\\end{itemize}");;;
+        padded = 0;
+        break;
+    case ORDEREDLIST:
+        pad(1);
+        printf("\\begin{enumerate}");;;
+        padded = 0;
+        print_latex_element_list(elt.children);
+        pad(1);
+        printf("\\end{enumerate}");;;
+        padded = 0;
+        break;
+    case LISTITEM:
+        pad(1);
+        printf("\\item ");;;
+        padded = 2;
+        print_latex_element_list(elt.children);
+        printf("\n");;;
+        break;
+    case BLOCKQUOTE:
+        pad(1);
+        printf("\\begin{quote}");;;
+        padded = 0;
+        print_latex_element(markdown(elt.contents.str, extensions));
+        printf("\\end{quote}");;;
+        padded = 0;
+        break;
+    case NOTE:
+        /* if contents.str == 0, then print note; else ignore, since this
+         * is a note block that has been incorporated into the notes list */
+        if (elt.contents.str == 0) {
+            printf("\\footnote{");;;
+            padded = 2;
+            print_latex_element_list(elt.children);
+            printf("}");;;
+            padded = 0; 
+        }
+        break;
+    case REFERENCE:
+        /* Nonprinting */
+        break;
+    default: 
+        fprintf(stderr, "print_latex_element encountered unknown element key = %d\n", elt.key); 
+        exit(EXIT_FAILURE);
+    }
+}
+
+/**********************************************************************
+
+  Functions for printing Elements as groff (mm macros)
+
+ ***********************************************************************/
+
+static bool in_list_item = false; /* True if we're parsing contents of a list item. */
+
+/* print_groff_string - print string, escaping for groff */
+static void print_groff_string(char *str) {
+    while (*str != '\0') {
+        switch (*str) {
+        case '\\':
+            printf("\\e");;;
+            break;
+        default:
+            putchar(*str);
+        }
+    str++;
+    }
+}
+
+/* print_groff_mm_element_list - print a list of elements as groff ms */
+static void print_groff_mm_element_list(element *list) {
+    int count = 1;
+    while (list != NULL) {
+        print_groff_mm_element(*list, count);
+        list = list->next;
+        count++;
+    }
+}
+
+/* print_groff_mm_element - print an element as groff ms */
+static void print_groff_mm_element(element elt, int count) {
+    int lev;
+    char *contents;
+    switch (elt.key) {
+    case SPACE:
+        printf("%s", elt.contents.str);
+        padded = 0;
+        break;
+    case LINEBREAK:
+        pad(1);
+        printf(".br");;;
+        padded = 0;
+        break;
+    case STR:
+        print_groff_string(elt.contents.str);
+        padded = 0;
+        break;
+    case ELLIPSIS:
+        printf("...");;;
+        break;
+    case EMDASH:
+        printf("\\[em]");;;
+        break;
+    case ENDASH:
+        printf("\\[en]");;;
+        break;
+    case APOSTROPHE:
+        printf("'");;;
+        break;
+    case SINGLEQUOTED:
+        printf("`");;;
+        print_groff_mm_element_list(elt.children);
+        printf("'");;;
+        break;
+    case DOUBLEQUOTED:
+        printf("\\[lq]");;;
+        print_groff_mm_element_list(elt.children);
+        printf("\\[rq]");;;
+        break;
+    case CODE:
+        printf("\\fC");;;
+        print_groff_string(elt.contents.str);
+        printf("\\fR");;;
+        padded = 0;
+        break;
+    case HTML:
+        /* don't print HTML */
+        break;
+    case LINK:
+        print_groff_mm_element_list(elt.contents.link.label);
+        printf(" (%s)", elt.contents.link.url);
+        padded = 0;
+        break;
+    case IMAGE:
+        printf("[IMAGE: ");;;
+        print_groff_mm_element_list(elt.contents.link.label);
+        printf("]");;;
+        padded = 0;
+        /* not supported */
+        break;
+    case EMPH:
+        printf("\\fI");;;
+        print_groff_mm_element_list(elt.children);
+        printf("\\fR");;;
+        padded = 0;
+        break;
+    case STRONG:
+        printf("\\fB");;;
+        print_groff_mm_element_list(elt.children);
+        printf("\\fR");;;
+        padded = 0;
+        break;
+    case LIST:
+        print_groff_mm_element_list(elt.children);
+        padded = 0;
+        break;
+    case 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(elt.contents.str, "\001");
+        print_groff_mm_element(markdown(contents, extensions), count);
+        while ((contents = strtok(NULL, "\001")))
+            print_groff_mm_element(markdown(contents, extensions), count);
+        break;
+    case H1: case H2: case H3: case H4: case H5: case H6:
+        lev = elt.key - H1 + 1;
+        pad(1);
+        printf(".H %d \"", lev);
+        print_groff_mm_element_list(elt.children);
+        printf("\"");
+        padded = 0;
+        break;
+    case PLAIN:
+        pad(1);
+        print_groff_mm_element_list(elt.children);
+        padded = 0;
+        break;
+    case PARA:
+        pad(1);
+        if (!in_list_item || count != 1)
+            printf(".P\n");;;
+        print_groff_mm_element_list(elt.children);
+        padded = 0;
+        break;
+    case HRULE:
+        pad(1);
+        printf("\\l'\\n(.lu*8u/10u'");;;
+        padded = 0;
+        break;
+    case HTMLBLOCK:
+        /* don't print HTML block */
+        break;
+    case VERBATIM:
+        pad(1);
+        printf(".VERBON 2\n");;;
+        print_groff_string(elt.contents.str);
+        printf(".VERBOFF");;;
+        padded = 0;
+        break;
+    case BULLETLIST:
+        pad(1);
+        printf(".BL");;;
+        padded = 0;
+        print_groff_mm_element_list(elt.children);
+        pad(1);
+        printf(".LE 1");;;
+        padded = 0;
+        break;
+    case ORDEREDLIST:
+        pad(1);
+        printf(".AL");;;
+        padded = 0;
+        print_groff_mm_element_list(elt.children);
+        pad(1);
+        printf(".LE 1");;;
+        padded = 0;
+        break;
+    case LISTITEM:
+        pad(1);
+        printf(".LI\n");;;
+        in_list_item = true;
+        padded = 2;
+        print_groff_mm_element_list(elt.children);
+        in_list_item = false;
+        break;
+    case BLOCKQUOTE:
+        pad(1);
+        printf(".DS I\n");;;
+        padded = 2;
+        print_groff_mm_element(markdown(elt.contents.str, extensions), 1);
+        pad(1);
+        printf(".DE");;;
+        padded = 0;
+        break;
+    case NOTE:
+        /* if contents.str == 0, then print note; else ignore, since this
+         * is a note block that has been incorporated into the notes list */
+        if (elt.contents.str == 0) {
+            printf("\\*F\n");;;
+            printf(".FS\n");;;
+            padded = 2;
+            print_groff_mm_element_list(elt.children);
+            pad(1);
+            printf(".FE\n");;;
+            padded = 1; 
+        }
+        break;
+    case REFERENCE:
+        /* Nonprinting */
+        break;
+    default: 
+        fprintf(stderr, "print_groff_mm_element encountered unknown element key = %d\n", elt.key); 
+        exit(EXIT_FAILURE);
+    }
+}
+
+/**********************************************************************
+
+  Parameterized function for printing an Element.
+
+ ***********************************************************************/
+
+void print_element(element elt, int format) {
+    switch (format) {
+    case HTML_FORMAT:
+        print_html_element(elt, false);
+        if (endnotes != NULL) {
+            pad(2);
+            print_html_endnotes();
+        }
+        break;
+    case LATEX_FORMAT:
+        print_latex_element(elt);
+        break;
+    case GROFF_MM_FORMAT:
+        print_groff_mm_element(elt, 1);
+        break;
+    default:
+        fprintf(stderr, "print_element - unknown format = %d\n", format); 
+        exit(EXIT_FAILURE);
+    }
+}