discount 1.2.6

data/ext/markdown.h

@@ -0,0 +1,125 @@
+#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 */
+    enum { WHITESPACE=0, CODE, QUOTE, MARKUP,
+	   HTML, STYLE, DL, UL, OL, 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 INSIDE_TAG	0x0020
+#define NO_PSEUDO_PROTO	0x0040
+#define CDATA_OUTPUT	0x0080
+#define USER_FLAGS	0x00FF
+#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 void mkd_cleanup(Document *);
+extern int  mkd_text(char *, int, FILE*, int);
+extern void mkd_basename(Document*, char *);
+
+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 *);
+
+#endif/*_MARKDOWN_D*/

data/ext/mkdio.c

@@ -0,0 +1,223 @@
+/*
+ * 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 = 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);
+}
+
+
+/* trim leading blanks from a header line
+ */
+static void
+snip(Line *p)
+{
+    CLIP(p->text, 0, 1);
+    p->dle = mkd_firstnonblank(p);
+}
+
+
+/* build a Document from any old input.
+ */
+typedef unsigned 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 char
+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;
+}

data/ext/mkdio.h

@@ -0,0 +1,58 @@
+#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_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*);
+
+/* 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_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_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/rbstrio.c

@@ -0,0 +1,29 @@
+#include "rbstrio.h"
+#include "ruby.h"
+
+#define INCREMENT 1024
+
+/* called when data is written to the stream. */
+static int rb_str_io_write(void *cookie, const char *data, int len) {
+    VALUE buf = cookie;
+    rb_str_cat(buf, data, len);
+    return len;
+}
+
+/* called when the stream is closed */
+static int rb_str_io_close(void *cookie) {
+    rb_gc_unregister_address(&cookie);
+    return 0;
+}
+
+/* create a stream backed by a Ruby string. */
+FILE *rb_str_io_new(VALUE buf) {
+    FILE *rv;
+    Check_Type(buf, T_STRING);
+    rv = funopen(buf, NULL, rb_str_io_write, NULL, rb_str_io_close);
+    /* TODO if (rv == NULL) */
+    rb_gc_register_address(&buf);
+    return rv;
+}
+
+// vim: ts=4 sw=4

data/ext/rbstrio.h

@@ -0,0 +1,5 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include "ruby.h"
+
+FILE *rb_str_io_new(VALUE buf);

data/ext/resource.c

@@ -0,0 +1,167 @@
+/* markdown: a C implementation of John Gruber's Markdown markup language.
+ *
+ * Copyright (C) 2007 David L Parsons.
+ * The redistribution terms are provided in the COPYRIGHT file that must
+ * be distributed with this source code.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "config.h"
+
+#include "cstring.h"
+#include "markdown.h"
+#include "amalloc.h"
+
+/* free a (single) line
+ */
+void
+___mkd_freeLine(Line *ptr)
+{
+    DELETE(ptr->text);
+    free(ptr);
+}
+
+
+/* free a list of lines
+ */
+void
+___mkd_freeLines(Line *p)
+{
+    if (p->next)
+	 ___mkd_freeLines(p->next);
+    ___mkd_freeLine(p);
+}
+
+
+/* bye bye paragraph.
+ */
+void
+___mkd_freeParagraph(Paragraph *p)
+{
+    if (p->next)
+	___mkd_freeParagraph(p->next);
+    if (p->down)
+	___mkd_freeParagraph(p->down);
+    if (p->text)
+	___mkd_freeLines(p->text);
+    free(p);
+}
+
+
+/* bye bye footnotes.
+ */
+void
+___mkd_freefootnotes(MMIOT *f)
+{
+    int i;
+
+    if ( f->footnotes ) {
+	for (i=0; i < S(*f->footnotes); i++) {
+	    DELETE(T(*f->footnotes)[i].tag);
+	    DELETE(T(*f->footnotes)[i].link);
+	    DELETE(T(*f->footnotes)[i].title);
+	}
+	DELETE(*f->footnotes);
+	free(f->footnotes);
+    }
+}
+
+
+/* initialize a new MMIOT
+ */
+void
+___mkd_initmmiot(MMIOT *f, void *footnotes)
+{
+    if ( f ) {
+	memset(f, 0, sizeof *f);
+	CREATE(f->in);
+	CREATE(f->out);
+	CREATE(f->Q);
+	if ( footnotes )
+	    f->footnotes = footnotes;
+	else {
+	    f->footnotes = malloc(sizeof f->footnotes[0]);
+	    CREATE(*f->footnotes);
+	}
+    }
+}
+
+
+/* free the contents of a MMIOT, but leave the object alone.
+ */
+void
+___mkd_freemmiot(MMIOT *f, void *footnotes)
+{
+    if ( f ) {
+	DELETE(f->in);
+	DELETE(f->out);
+	DELETE(f->Q);
+	if ( f->footnotes != footnotes )
+	    ___mkd_freefootnotes(f);
+	memset(f, 0, sizeof *f);
+    }
+}
+
+
+/* free lines up to an barrier.
+ */
+void
+___mkd_freeLineRange(Line *anchor, Line *stop)
+{
+    Line *r = anchor->next;
+
+    if ( r != stop ) {
+	while ( r && (r->next != stop) )
+	    r = r->next;
+	if ( r ) r->next = 0;
+	___mkd_freeLines(anchor->next);
+    }
+    anchor->next = 0;
+}
+
+
+/* clean up everything allocated in __mkd_compile()
+ */
+void
+mkd_cleanup(Document *doc)
+{
+    if ( doc ) {
+	if ( doc->ctx ) {
+	    ___mkd_freemmiot(doc->ctx, 0);
+	    free(doc->ctx);
+	}
+
+	if ( doc->code) ___mkd_freeParagraph(doc->code);
+	if ( doc->headers ) ___mkd_freeLines(doc->headers);
+	if ( T(doc->content) ) ___mkd_freeLines(T(doc->content));
+	memset(doc, 0, sizeof doc[0]);
+	free(doc);
+    }
+}
+
+
+/* write output in XML format
+ */
+void
+___mkd_xml(char *p, int size, FILE *out)
+{
+    char c;
+
+    while ( size-- > 0 ) {
+	if ( !isascii(c = *p++) )
+	    continue;
+	switch (c) {
+	case '<': fputs("&lt;", out);   break;
+	case '>': fputs("&gt;", out);   break;
+	case '&': fputs("&amp;", out);  break;
+	case '"': fputs("&quot;", out); break;
+	case '\'':fputs("&apos;", out); break;
+	default:  putc(c,out);          break;
+	}
+    }
+}