moredown 1.0.0

data/ext/markdown.h

@@ -0,0 +1,135 @@
+#ifndef _MARKDOWN_D
+#define _MARKDOWN_D
+
+#include "cstring.h"
+
+/* reference-style links (and images) are stored in an array
+ * of footnotes.
+ */
+typedef struct footnote {
+    Cstring tag;		/* the tag for the reference link */
+    Cstring link;		/* what this footnote points to */
+    Cstring title;		/* what it's called (TITLE= attribute) */
+    int height, width;		/* dimensions (for image link) */
+} Footnote;
+
+/* each input line is read into a Line, which contains the line,
+ * the offset of the first non-space character [this assumes 
+ * that all tabs will be expanded to spaces!], and a pointer to
+ * the next line.
+ */
+typedef struct line {
+    Cstring text;
+    struct line *next;
+    int dle;
+} Line;
+
+
+/* a paragraph is a collection of Lines, with links to the next paragraph
+ * and (if it's a QUOTE, UL, or OL) to the reparsed contents of this
+ * paragraph.
+ */
+typedef struct paragraph {
+    struct paragraph *next;	/* next paragraph */
+    struct paragraph *down;	/* recompiled contents of this paragraph */
+    struct line *text;		/* all the text in this paragraph */
+    char *ident;		/* %id% tag for QUOTE */
+    enum { WHITESPACE=0, CODE, QUOTE, MARKUP,
+	   HTML, STYLE, DL, UL, OL, AL, LISTITEM,
+	   HDR, HR } typ;
+    enum { IMPLICIT=0, PARA, CENTER} align;
+    int hnumber;		/* <Hn> for typ == HDR */
+} Paragraph;
+
+enum { ETX, SETEXT };	/* header types */
+
+
+typedef struct block {
+    enum { bTEXT, bSTAR, bUNDER } b_type;
+    int  b_count;
+    char b_char;
+    Cstring b_text;
+    Cstring b_post;
+} block;
+
+typedef STRING(block) Qblock;
+
+
+/* a magic markdown io thing holds all the data structures needed to
+ * do the backend processing of a markdown document
+ */
+typedef struct mmiot {
+    Cstring out;
+    Cstring in;
+    Qblock Q;
+    int isp;
+    STRING(Footnote) *footnotes;
+    int flags;
+#define DENY_A		0x0001
+#define DENY_IMG	0x0002
+#define DENY_SMARTY	0x0004
+#define DENY_HTML	0x0008
+#define STRICT		0x0010
+#define INSIDE_TAG	0x0020
+#define NO_PSEUDO_PROTO	0x0040
+#define CDATA_OUTPUT	0x0080
+#define TOC		0x1000
+#define MKD_1_COMPAT	0x2000
+#define USER_FLAGS	0xF0FF
+#define EMBEDDED	DENY_A|DENY_IMG|NO_PSEUDO_PROTO|CDATA_OUTPUT
+    char *base;
+} MMIOT;
+
+
+/*
+ * the mkdio text input functions return a document structure,
+ * which contains a header (retrieved from the document if
+ * markdown was configured * with the * --enable-pandoc-header
+ * and the document begins with a pandoc-style header) and the
+ * root of the linked list of Lines.
+ */
+typedef struct document {
+    Line *headers;		/* title -> author(s) -> date */
+    ANCHOR(Line) content;	/* uncompiled text, not valid after compile() */
+    Paragraph *code;		/* intermediate code generated by compile() */
+    int compiled;		/* set after mkd_compile() */
+    int html;			/* set after (internal) htmlify() */
+    int tabstop;		/* for properly expanding tabs (ick) */
+    MMIOT *ctx;			/* backend buffers, flags, and structures */
+    char *base;			/* url basename for url fragments */
+} Document;
+
+
+extern int  mkd_firstnonblank(Line *);
+extern int  mkd_compile(Document *, int);
+extern int  mkd_document(Document *, char **);
+extern int  mkd_generatehtml(Document *, FILE *);
+extern int  mkd_style(Document *, FILE *);
+extern void mkd_cleanup(Document *);
+extern int  mkd_text(char *, int, FILE*, int);
+extern void mkd_basename(Document*, char *);
+extern void mkd_string_to_anchor(char*,int, void(*)(int,void*), void*);
+
+extern Document *mkd_in(FILE *, int);
+extern Document *mkd_string(char*,int, int);
+
+#define NO_HEADER	0x0100
+#define STD_TABSTOP	0x0200
+#define INPUT_MASK	(NO_HEADER|STD_TABSTOP)
+
+
+/* internal resource handling functions.
+ */
+extern void ___mkd_freeLine(Line *);
+extern void ___mkd_freeLines(Line *);
+extern void ___mkd_freeParagraph(Paragraph *);
+extern void ___mkd_freefootnotes(MMIOT *);
+extern void ___mkd_initmmiot(MMIOT *, void *);
+extern void ___mkd_freemmiot(MMIOT *, void *);
+extern void ___mkd_freeLineRange(Line *, Line *);
+extern void ___mkd_xml(char *, int, FILE *);
+extern void ___mkd_reparse(char *, int, int, MMIOT*);
+extern void ___mkd_emblock(MMIOT*);
+extern void ___mkd_tidy(Line *);
+
+#endif/*_MARKDOWN_D*/

data/ext/mkdio.c

@@ -0,0 +1,241 @@
+/*
+ * mkdio -- markdown front end input functions
+ *
+ * Copyright (C) 2007 David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+
+typedef ANCHOR(Line) LineAnchor;
+
+/* create a new blank Document
+ */
+static Document*
+new_Document()
+{
+    Document *ret = calloc(sizeof(Document), 1);
+
+    if ( ret ) {
+	if (( ret->ctx = calloc(sizeof(MMIOT), 1) ))
+	    return ret;
+	free(ret);
+    }
+    return 0;
+}
+
+
+/* add a line to the markdown input chain
+ */
+static void
+queue(Document* a, Cstring *line)
+{
+    Line *p = calloc(sizeof *p, 1);
+    unsigned char c;
+    int xp = 0;
+    int           size = S(*line);
+    unsigned char *str = (unsigned char*)T(*line);
+
+    CREATE(p->text);
+    ATTACH(a->content, p);
+
+    while ( size-- ) {
+	if ( (c = *str++) == '\t' ) {
+	    /* expand tabs into ->tabstop spaces.  We use ->tabstop
+	     * because the ENTIRE FREAKING COMPUTER WORLD uses editors
+	     * that don't do ^T/^D, but instead use tabs for indentation,
+	     * and, of course, set their tabs down to 4 spaces 
+	     */
+	    do {
+		EXPAND(p->text) = ' ';
+	    } while ( ++xp % a->tabstop );
+	}
+	else if ( c >= ' ' ) {
+	    EXPAND(p->text) = c;
+	    ++xp;
+	}
+    }
+    EXPAND(p->text) = 0;
+    S(p->text)--;
+    p->dle = mkd_firstnonblank(p);
+}
+
+
+#ifdef PANDOC_HEADER
+/* trim leading blanks from a header line
+ */
+static void
+snip(Line *p)
+{
+    CLIP(p->text, 0, 1);
+    p->dle = mkd_firstnonblank(p);
+}
+#endif
+
+
+/* build a Document from any old input.
+ */
+typedef int (*getc_func)(void*);
+
+Document *
+populate(getc_func getc, void* ctx, int flags)
+{
+    Cstring line;
+    Document *a = new_Document();
+    int c;
+#ifdef PANDOC_HEADER
+    int pandoc = 0;
+#endif
+
+    if ( !a ) return 0;
+
+    a->tabstop = (flags & STD_TABSTOP) ? 4 : TABSTOP;
+
+    CREATE(line);
+
+    while ( (c = (*getc)(ctx)) != EOF ) {
+	if ( c == '\n' ) {
+#ifdef PANDOC_HEADER
+	    if ( pandoc != EOF && pandoc < 3 ) {
+		if ( S(line) && (T(line)[0] == '%') )
+		    pandoc++;
+		else
+		    pandoc = EOF;
+	    }
+#endif
+	    queue(a, &line);
+	    S(line) = 0;
+	}
+	else
+	    EXPAND(line) = c;
+    }
+
+    if ( S(line) )
+	queue(a, &line);
+
+    DELETE(line);
+
+#ifdef PANDOC_HEADER
+    if ( (pandoc == 3) && !(flags & NO_HEADER) ) {
+	/* the first three lines started with %, so we have a header.
+	 * clip the first three lines out of content and hang them
+	 * off header.
+	 */
+	a->headers = T(a->content);
+	T(a->content) = a->headers->next->next->next;
+	a->headers->next->next->next = 0;
+	snip(a->headers);
+	snip(a->headers->next);
+	snip(a->headers->next->next);
+    }
+#endif
+
+    return a;
+}
+
+
+/* convert a file into a linked list
+ */
+Document *
+mkd_in(FILE *f, int flags)
+{
+    return populate((getc_func)fgetc, f, flags & INPUT_MASK);
+}
+
+
+/* return a single character out of a buffer
+ */
+struct string_ctx {
+    char *data;		/* the unread data */
+    int   size;		/* and how much is there? */
+} ;
+
+
+static int
+strget(struct string_ctx *in)
+{
+    if ( !in->size ) return EOF;
+
+    --(in->size);
+
+    return *(in->data)++;
+}
+
+
+/* convert a block of text into a linked list
+ */
+Document *
+mkd_string(char *buf, int len, int flags)
+{
+    struct string_ctx about;
+
+    about.data = buf;
+    about.size = len;
+
+    return populate((getc_func)strget, &about, flags & INPUT_MASK);
+}
+
+
+/* write the html to a file (xmlified if necessary)
+ */
+int
+mkd_generatehtml(Document *p, FILE *output)
+{
+    char *doc;
+    int szdoc;
+
+    if ( (szdoc = mkd_document(p, &doc)) != EOF ) {
+	if ( p->ctx->flags & CDATA_OUTPUT )
+	    ___mkd_xml(doc, szdoc, output);
+	else
+	    fwrite(doc, szdoc, 1, output);
+	putc('\n', output);
+	return 0;
+    }
+    return -1;
+}
+
+
+/* convert some markdown text to html
+ */
+int
+markdown(Document *document, FILE *out, int flags)
+{
+    if ( mkd_compile(document, flags) ) {
+	mkd_generatehtml(document, out);
+	mkd_cleanup(document);
+	return 0;
+    }
+    return -1;
+}
+
+
+void
+mkd_basename(Document *document, char *base)
+{
+    if ( document )
+	document->base = base;
+}
+
+
+/* write out a Cstring, mangled into a form suitable for `<a href=` or `<a id=`
+ */
+void
+mkd_string_to_anchor(char *s, int len, void(*outchar)(int,void*), void *out)
+{
+    for ( ; len-- > 0; ++s ) {
+	if ( *s == ' ' || *s == '&' || *s == '<' || *s == '"' )
+	    (*outchar)('+', out);
+	else if ( isalnum(*s) || ispunct(*s) )
+	    (*outchar)(*s, out);
+	else
+	    (*outchar)('~',out);
+    }
+}

data/ext/mkdio.h

@@ -0,0 +1,66 @@
+#ifndef _MKDIO_D
+#define _MKDIO_D
+
+#include <stdio.h>
+
+typedef void MMIOT;
+
+/* line builder for markdown()
+ */
+MMIOT *mkd_in(FILE*,int);		/* assemble input from a file */
+MMIOT *mkd_string(char*,int,int);	/* assemble input from a buffer */
+
+void mkd_basename(MMIOT*,char*);
+
+/* compilation, debugging, cleanup
+ */
+int mkd_compile(MMIOT*, int);
+int mkd_generatehtml(MMIOT*,FILE*);
+int mkd_generatetoc(MMIOT*,FILE*);
+int mkd_xhtmlpage(MMIOT*,int,FILE*);
+int mkd_cleanup(MMIOT*);
+
+/* markup functions
+ */
+int mkd_text(char *, int, FILE*, int);
+int mkd_style(MMIOT*, FILE*);
+int mkd_dump(MMIOT*, FILE*, int, char*);
+int markdown(MMIOT*, FILE*, int);
+void mkd_basename(MMIOT*,char*);
+void mkd_string_to_anchor(char *, int, int (*)(int,void*), void*);
+
+/* header block access
+ */
+char* mkd_doc_title(MMIOT*);
+char* mkd_doc_author(MMIOT*);
+char* mkd_doc_date(MMIOT*);
+
+/* compiled data access
+ */
+int mkd_document(MMIOT*, char**);
+
+/* version#.
+ */
+extern char markdown_version[];
+
+/* special flags for markdown() and mkd_text()
+ */
+#define MKD_NOLINKS	0x0001	/* don't do link processing, block <a> tags  */
+#define MKD_NOIMAGE	0x0002	/* don't do image processing, block <img> */
+#define MKD_NOPANTS	0x0004	/* don't run smartypants() */
+#define MKD_NOHTML	0x0008	/* don't allow raw html through AT ALL */
+#define MKD_STRICT	0x0010	/* disable SUPERSCRIPT, RELAXED_EMPHASIS */
+#define MKD_TAGTEXT	0x0020	/* don't expand `_` and `*` */
+#define MKD_NO_EXT	0x0040	/* don't allow pseudo-protocols */
+#define MKD_CDATA	0x0080	/* generate code for xml ![CDATA[...]] */
+#define MKD_TOC		0x1000	/* do table-of-contents processing */
+#define MKD_1_COMPAT	0x2000	/* compatability with MarkdownTest_1.0 */
+#define MKD_EMBED	MKD_NOLINKS|MKD_NOIMAGE|MKD_TAGTEXT
+
+/* special flags for mkd_in() and mkd_string()
+ */
+#define MKD_NOHEADER	0x0100	/* don't process header blocks */
+#define MKD_TABSTOP	0x0200	/* expand tabs to 4 spaces */
+
+
+#endif/*_MKDIO_D*/

data/ext/rdiscount.c

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include "ruby.h"
+#include "mkdio.h"
+
+static VALUE rb_cRDiscount;
+
+static VALUE
+rb_rdiscount_to_html(int argc, VALUE *argv, VALUE self)
+{
+    /* grab char pointer to markdown input text */
+    char *res;
+    int szres;
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    VALUE buf = rb_str_buf_new(1024);
+    Check_Type(text, T_STRING);
+
+    int flags = rb_rdiscount__get_flags(self);
+
+    MMIOT *doc = mkd_string(RSTRING_PTR(text), RSTRING_LEN(text), flags);
+
+    if ( mkd_compile(doc, flags) ) {
+        szres = mkd_document(doc, &res);
+
+        if ( szres != EOF ) {
+            rb_str_cat(buf, res, szres);
+            rb_str_cat(buf, "\n", 1);
+        }
+    }
+    mkd_cleanup(doc);
+
+    return buf;
+}
+
+static VALUE
+rb_rdiscount_toc_content(int argc, VALUE *argv, VALUE self)
+{
+    char *res;
+    int szres;
+
+    int flags = rb_rdiscount__get_flags(self);
+
+    /* grab char pointer to markdown input text */
+    VALUE text = rb_funcall(self, rb_intern("text"), 0);
+    Check_Type(text, T_STRING);
+
+    /* allocate a ruby string buffer and wrap it in a stream */
+    VALUE buf = rb_str_buf_new(4096);
+
+    MMIOT *doc = mkd_string(RSTRING_PTR(text), RSTRING_LEN(text), flags);
+
+    if ( mkd_compile(doc, flags) ) {
+        szres = mkd_toc(doc, &res);
+
+        if ( szres != EOF ) {
+            rb_str_cat(buf, res, szres);
+            rb_str_cat(buf, "\n", 1);
+        }
+    }
+    mkd_cleanup(doc);
+
+    return buf;
+}
+
+int rb_rdiscount__get_flags(VALUE ruby_obj)
+{
+  /* compile flags */
+  int flags = MKD_TABSTOP | MKD_NOHEADER;
+
+  /* smart */
+  if ( rb_funcall(ruby_obj, rb_intern("smart"), 0) != Qtrue )
+      flags = flags | MKD_NOPANTS;
+
+  /* filter_html */
+  if ( rb_funcall(ruby_obj, rb_intern("filter_html"), 0) == Qtrue )
+      flags = flags | MKD_NOHTML;
+
+  /* generate_toc */
+  if ( rb_funcall(ruby_obj, rb_intern("generate_toc"), 0) == Qtrue)
+    flags = flags | MKD_TOC;
+
+  return flags;
+}
+
+
+void Init_rdiscount()
+{
+    rb_cRDiscount = rb_define_class("RDiscount", rb_cObject);
+    rb_define_method(rb_cRDiscount, "to_html", rb_rdiscount_to_html, -1);
+    rb_define_method(rb_cRDiscount, "toc_content", rb_rdiscount_toc_content, -1);
+}
+
+/* vim: set ts=4 sw=4: */