rdiscountwl 1.0.0.1

data/ext/markdown.h

@@ -0,0 +1,238 @@
+#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) */
+    int dealloc;		/* deallocation needed? */
+    int refnumber;
+    int flags;
+#define EXTRA_BOOKMARK	0x01
+#define REFERENCED	0x02
+} 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 enum { chk_text, chk_code,
+	       chk_hr, chk_dash,
+	       chk_tilde, chk_backtick,
+	       chk_equal } line_type;
+typedef struct line {
+    Cstring text;
+    struct line *next;
+    int dle;			/* leading indent on the line */
+    int flags;			/* special attributes for this line */
+#define PIPECHAR	0x01		/* line contains a | */
+#define CHECKED		0x02
+
+    line_type kind;
+    int count;
+} 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 */
+    char *lang;         /* lang attribute for CODE */
+    enum { WHITESPACE=0, CODE, QUOTE, MARKUP,
+	   HTML, STYLE, DL, UL, OL, AL, LISTITEM,
+	   HDR, HR, TABLE, SOURCE } 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;
+
+
+typedef char* (*mkd_callback_t)(const char*, const int, void*);
+typedef void  (*mkd_free_t)(char*, void*);
+
+typedef struct callback_data {
+    void *e_data;		/* private data for callbacks */
+    mkd_callback_t e_url;	/* url edit callback */
+    mkd_callback_t e_flags;	/* extra href flags callback */
+    mkd_free_t e_free;		/* edit/flags callback memory deallocator */
+} Callback_data;
+
+
+struct escaped { 
+    char *text;
+    struct escaped *up;
+} ;
+
+
+struct footnote_list {
+    int reference;
+    STRING(Footnote) note;
+} ;
+
+
+/* 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;
+    struct escaped *esc;
+    char *ref_prefix;
+    struct footnote_list *footnotes;
+    DWORD flags;
+#define MKD_NOLINKS	0x00000001
+#define MKD_NOIMAGE	0x00000002
+#define MKD_NOPANTS	0x00000004
+#define MKD_NOHTML	0x00000008
+#define MKD_STRICT	0x00000010
+#define MKD_TAGTEXT	0x00000020
+#define MKD_NO_EXT	0x00000040
+#define MKD_CDATA	0x00000080
+#define MKD_NOSUPERSCRIPT 0x00000100
+#define MKD_NORELAXED	0x00000200
+#define MKD_NOTABLES	0x00000400
+#define MKD_NOSTRIKETHROUGH 0x00000800
+#define MKD_TOC		0x00001000
+#define MKD_1_COMPAT	0x00002000
+#define MKD_AUTOLINK	0x00004000
+#define MKD_SAFELINK	0x00008000
+#define MKD_NOHEADER	0x00010000
+#define MKD_TABSTOP	0x00020000
+#define MKD_NODIVQUOTE	0x00040000
+#define MKD_NOALPHALIST	0x00080000
+#define MKD_NODLIST	0x00100000
+#define MKD_EXTRA_FOOTNOTE 0x00200000
+#define MKD_NOSTYLE	0x00400000
+#define MKD_NODLDISCOUNT 0x00800000
+#define	MKD_DLEXTRA	0x01000000
+#define MKD_FENCEDCODE	0x02000000
+#define MKD_IDANCHOR	0x04000000
+#define MKD_GITHUBTAGS	0x08000000
+#define MKD_URLENCODEDANCHOR 0x10000000
+#define IS_LABEL	0x20000000
+#define USER_FLAGS	0x3FFFFFFF
+#define INPUT_MASK	(MKD_NOHEADER|MKD_TABSTOP)
+
+    Callback_data *cb;
+} MMIOT;
+
+
+#define MKD_EOLN	3
+
+
+/*
+ * 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 {
+    int magic;			/* "I AM VALID" magic number */
+#define VALID_DOCUMENT		0x19600731
+    Line *title;
+    Line *author;
+    Line *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) */
+    char *ref_prefix;
+    MMIOT *ctx;			/* backend buffers, flags, and structures */
+    Callback_data cb;		/* callback functions & private data */
+} Document;
+
+
+/*
+ * economy FILE-type structure for pulling characters out of a
+ * fixed-length string.
+ */
+struct string_stream {
+    const char *data;	/* the unread data */
+    int   size;		/* and how much is there? */
+} ;
+
+
+extern int  mkd_firstnonblank(Line *);
+extern int  mkd_compile(Document *, DWORD);
+extern int  mkd_document(Document *, char **);
+extern int  mkd_generatehtml(Document *, FILE *);
+extern int  mkd_css(Document *, char **);
+extern int  mkd_generatecss(Document *, FILE *);
+#define mkd_style mkd_generatecss
+extern int  mkd_xml(char *, int , char **);
+extern int  mkd_generatexml(char *, int, FILE *);
+extern void mkd_cleanup(Document *);
+extern int  mkd_line(char *, int, char **, DWORD);
+extern int  mkd_generateline(char *, int, FILE*, DWORD);
+#define mkd_text mkd_generateline
+extern void mkd_basename(Document*, char *);
+
+typedef int (*mkd_sta_function_t)(const int,const void*);
+extern void mkd_string_to_anchor(char*,int, mkd_sta_function_t, void*, int, DWORD);
+
+extern Document *mkd_in(FILE *, DWORD);
+extern Document *mkd_string(const char*,int, DWORD);
+
+extern Document *gfm_in(FILE *, DWORD);
+extern Document *gfm_string(const char*,int, DWORD);
+
+extern void mkd_initialize();
+extern void mkd_shlib_destructor();
+
+extern void mkd_ref_prefix(Document*, char*);
+
+/* internal resource handling functions.
+ */
+extern void ___mkd_freeLine(Line *);
+extern void ___mkd_freeLines(Line *);
+extern void ___mkd_freeParagraph(Paragraph *);
+extern void ___mkd_freefootnote(Footnote *);
+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*, char*);
+extern void ___mkd_emblock(MMIOT*);
+extern void ___mkd_tidy(Cstring *);
+
+extern Document *__mkd_new_Document();
+extern void __mkd_enqueue(Document*, Cstring *);
+extern void __mkd_header_dle(Line *);
+
+extern int  __mkd_io_strget(struct string_stream *);
+
+/* utility function to do some operation and exit the current function
+ * if it fails
+ */
+#define DO_OR_DIE(op) if ( (op) == EOF ) return EOF; else 1
+
+#endif/*_MARKDOWN_D*/

data/ext/mkdio.c

@@ -0,0 +1,360 @@
+/*
+ * 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
+ */
+Document*
+__mkd_new_Document()
+{
+    Document *ret = calloc(sizeof(Document), 1);
+
+    if ( ret ) {
+	if ( ret->ctx = calloc(sizeof(MMIOT), 1) ) {
+	    ret->magic = VALID_DOCUMENT;
+	    return ret;
+	}
+	free(ret);
+    }
+    return 0;
+}
+
+
+/* add a line to the markdown input chain, expanding tabs and
+ * noting the presence of special characters as we go.
+ */
+void
+__mkd_enqueue(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 >= ' ' ) {
+	    if ( c == '|' )
+		p->flags |= PIPECHAR;
+	    EXPAND(p->text) = c;
+	    ++xp;
+	}
+    }
+    EXPAND(p->text) = 0;
+    S(p->text)--;
+    p->dle = mkd_firstnonblank(p);
+}
+
+
+/* trim leading blanks from a header line
+ */
+void
+__mkd_header_dle(Line *p)
+{
+    CLIP(p->text, 0, 1);
+    p->dle = mkd_firstnonblank(p);
+}
+
+
+/* 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 = __mkd_new_Document();
+    int c;
+    int pandoc = 0;
+
+    if ( !a ) return 0;
+
+    a->tabstop = (flags & MKD_TABSTOP) ? 4 : TABSTOP;
+
+    CREATE(line);
+
+    while ( (c = (*getc)(ctx)) != EOF ) {
+	if ( c == '\n' ) {
+	    if ( pandoc != EOF && pandoc < 3 ) {
+		if ( S(line) && (T(line)[0] == '%') )
+		    pandoc++;
+		else
+		    pandoc = EOF;
+	    }
+	    __mkd_enqueue(a, &line);
+	    S(line) = 0;
+	}
+	else if ( isprint(c) || isspace(c) || (c & 0x80) )
+	    EXPAND(line) = c;
+    }
+
+    if ( S(line) )
+	__mkd_enqueue(a, &line);
+
+    DELETE(line);
+
+    if ( (pandoc == 3) && !(flags & (MKD_NOHEADER|MKD_STRICT)) ) {
+	/* the first three lines started with %, so we have a header.
+	 * clip the first three lines out of content and hang them
+	 * off header.
+	 */
+	Line *headers = T(a->content);
+
+	a->title = headers;             __mkd_header_dle(a->title);
+	a->author= headers->next;       __mkd_header_dle(a->author);
+	a->date  = headers->next->next; __mkd_header_dle(a->date);
+
+	T(a->content) = headers->next->next->next;
+    }
+
+    return a;
+}
+
+
+/* convert a file into a linked list
+ */
+Document *
+mkd_in(FILE *f, DWORD flags)
+{
+    return populate((getc_func)fgetc, f, flags & INPUT_MASK);
+}
+
+
+/* return a single character out of a buffer
+ */
+int
+__mkd_io_strget(struct string_stream *in)
+{
+    if ( !in->size ) return EOF;
+
+    --(in->size);
+
+    return *(in->data)++;
+}
+
+
+/* convert a block of text into a linked list
+ */
+Document *
+mkd_string(const char *buf, int len, DWORD flags)
+{
+    struct string_stream about;
+
+    about.data = buf;
+    about.size = len;
+
+    return populate((getc_func)__mkd_io_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;
+
+    DO_OR_DIE( szdoc = mkd_document(p,&doc) );
+    if ( p->ctx->flags & MKD_CDATA )
+	DO_OR_DIE( mkd_generatexml(doc, szdoc, output) );
+    else if ( fwrite(doc, szdoc, 1, output) != 1 )
+	return EOF;
+    DO_OR_DIE( putc('\n', output) );
+    return 0;
+}
+
+
+/* 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;
+}
+
+
+/* write out a Cstring, mangled into a form suitable for `<a href=` or `<a id=`
+ */
+void
+mkd_string_to_anchor(char *s, int len, mkd_sta_function_t outchar,
+				       void *out, int labelformat,
+				       DWORD flags)
+{
+    static const unsigned char hexchars[] = "0123456789abcdef";
+    unsigned char c;
+
+    int i, size;
+    char *line;
+
+    size = mkd_line(s, len, &line, IS_LABEL);
+
+    if ( !(flags & MKD_URLENCODEDANCHOR)
+	 && labelformat
+	 && (size>0) && !isalpha(line[0]) )
+	(*outchar)('L',out);
+    for ( i=0; i < size ; i++ ) {
+	c = line[i];
+	if ( labelformat ) {
+	    if ( isalnum(c) || (c == '_') || (c == ':') || (c == '-') || (c == '.' ) )
+		(*outchar)(c, out);
+	    else if ( flags & MKD_URLENCODEDANCHOR ) {
+		(*outchar)('%', out);
+		(*outchar)(hexchars[c >> 4 & 0xf], out);
+		(*outchar)(hexchars[c      & 0xf], out);
+	    }
+	    else
+		(*outchar)('.', out);
+	}
+	else
+	    (*outchar)(c,out);
+    }
+	
+    if (line)
+	free(line);
+}
+
+
+/*  ___mkd_reparse() a line
+ */
+static void
+mkd_parse_line(char *bfr, int size, MMIOT *f, int flags)
+{
+    ___mkd_initmmiot(f, 0);
+    f->flags = flags & USER_FLAGS;
+    ___mkd_reparse(bfr, size, 0, f, 0);
+    ___mkd_emblock(f);
+}
+
+
+/* ___mkd_reparse() a line, returning it in malloc()ed memory
+ */
+int
+mkd_line(char *bfr, int size, char **res, DWORD flags)
+{
+    MMIOT f;
+    int len;
+    
+    mkd_parse_line(bfr, size, &f, flags);
+
+    if ( len = S(f.out) ) {
+	/* kludge alert;  we know that T(f.out) is malloced memory,
+	 * so we can just steal it away.   This is awful -- there
+	 * should be an opaque method that transparently moves 
+	 * the pointer out of the embedded Cstring.
+	 */
+	EXPAND(f.out) = 0;
+	*res = T(f.out);
+	T(f.out) = 0;
+	S(f.out) = ALLOCATED(f.out) = 0;
+    }
+    else {
+	 *res = 0;
+	 len = EOF;
+     }
+    ___mkd_freemmiot(&f, 0);
+    return len;
+}
+
+
+/* ___mkd_reparse() a line, writing it to a FILE
+ */
+int
+mkd_generateline(char *bfr, int size, FILE *output, DWORD flags)
+{
+    MMIOT f;
+    int status;
+
+    mkd_parse_line(bfr, size, &f, flags);
+    if ( flags & MKD_CDATA )
+	status = mkd_generatexml(T(f.out), S(f.out), output) != EOF;
+    else
+	status = fwrite(T(f.out), S(f.out), 1, output) == S(f.out);
+
+    ___mkd_freemmiot(&f, 0);
+    return status ? 0 : EOF;
+}
+
+
+/* set the url display callback
+ */
+void
+mkd_e_url(Document *f, mkd_callback_t edit)
+{
+    if ( f )
+	f->cb.e_url = edit;
+}
+
+
+/* set the url options callback
+ */
+void
+mkd_e_flags(Document *f, mkd_callback_t edit)
+{
+    if ( f )
+	f->cb.e_flags = edit;
+}
+
+
+/* set the url display/options deallocator
+ */
+void
+mkd_e_free(Document *f, mkd_free_t dealloc)
+{
+    if ( f )
+	f->cb.e_free = dealloc;
+}
+
+
+/* set the url display/options context data field
+ */
+void
+mkd_e_data(Document *f, void *data)
+{
+    if ( f )
+	f->cb.e_data = data;
+}
+
+
+/* set the href prefix for markdown extra style footnotes
+ */
+void
+mkd_ref_prefix(Document *f, char *data)
+{
+    if ( f )
+	f->ref_prefix = data;
+}

data/ext/mkdio.h

@@ -0,0 +1,122 @@
+#ifndef _MKDIO_D
+#define _MKDIO_D
+
+#include <stdio.h>
+
+typedef void MMIOT;
+
+typedef unsigned int mkd_flag_t;
+
+/* line builder for markdown()
+ */
+MMIOT *mkd_in(FILE*,mkd_flag_t);		/* assemble input from a file */
+MMIOT *mkd_string(const char*,int,mkd_flag_t);	/* assemble input from a buffer */
+
+/* line builder for github flavoured markdown
+ */
+MMIOT *gfm_in(FILE*,mkd_flag_t);		/* assemble input from a file */
+MMIOT *gfm_string(const char*,int,mkd_flag_t);	/* assemble input from a buffer */
+
+void mkd_basename(MMIOT*,char*);
+
+void mkd_initialize();
+void mkd_with_html5_tags();
+void mkd_shlib_destructor();
+
+/* compilation, debugging, cleanup
+ */
+int mkd_compile(MMIOT*, mkd_flag_t);
+void mkd_cleanup(MMIOT*);
+
+/* markup functions
+ */
+int mkd_dump(MMIOT*, FILE*, int, char*);
+int markdown(MMIOT*, FILE*, mkd_flag_t);
+int mkd_line(char *, int, char **, mkd_flag_t);
+typedef int (*mkd_sta_function_t)(const int,const void*);
+void mkd_string_to_anchor(char *, int, mkd_sta_function_t, void*, int);
+int mkd_xhtmlpage(MMIOT*,int,FILE*);
+
+/* 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**);
+int mkd_toc(MMIOT*, char**);
+int mkd_css(MMIOT*, char **);
+int mkd_xml(char *, int, char **);
+
+/* write-to-file functions
+ */
+int mkd_generatehtml(MMIOT*,FILE*);
+int mkd_generatetoc(MMIOT*,FILE*);
+int mkd_generatexml(char *, int,FILE*);
+int mkd_generatecss(MMIOT*,FILE*);
+#define mkd_style mkd_generatecss
+int mkd_generateline(char *, int, FILE*, mkd_flag_t);
+#define mkd_text mkd_generateline
+
+/* url generator callbacks
+ */
+typedef char * (*mkd_callback_t)(const char*, const int, void*);
+typedef void   (*mkd_free_t)(char*, void*);
+
+void mkd_e_url(void *, mkd_callback_t);
+void mkd_e_flags(void *, mkd_callback_t);
+void mkd_e_free(void *, mkd_free_t );
+void mkd_e_data(void *, void *);
+
+/* version#.
+ */
+extern char markdown_version[];
+void mkd_mmiot_flags(FILE *, MMIOT *, int);
+void mkd_flags_are(FILE*, mkd_flag_t, int);
+
+void mkd_ref_prefix(MMIOT*, char*);
+
+
+/* special flags for markdown() and mkd_text()
+ */
+#define MKD_NOLINKS	0x00000001	/* don't do link processing, block <a> tags  */
+#define MKD_NOIMAGE	0x00000002	/* don't do image processing, block <img> */
+#define MKD_NOPANTS	0x00000004	/* don't run smartypants() */
+#define MKD_NOHTML	0x00000008	/* don't allow raw html through AT ALL */
+#define MKD_STRICT	0x00000010	/* disable SUPERSCRIPT, RELAXED_EMPHASIS */
+#define MKD_TAGTEXT	0x00000020	/* process text inside an html tag; no
+					 * <em>, no <bold>, no html or [] expansion */
+#define MKD_NO_EXT	0x00000040	/* don't allow pseudo-protocols */
+#define MKD_NOEXT	MKD_NO_EXT	/* ^^^ (aliased for user convenience) */
+#define MKD_CDATA	0x00000080	/* generate code for xml ![CDATA[...]] */
+#define MKD_NOSUPERSCRIPT 0x00000100	/* no A^B */
+#define MKD_NORELAXED	0x00000200	/* emphasis happens /everywhere/ */
+#define MKD_NOTABLES	0x00000400	/* disallow tables */
+#define MKD_NOSTRIKETHROUGH 0x00000800	/* forbid ~~strikethrough~~ */
+#define MKD_TOC		0x00001000	/* do table-of-contents processing */
+#define MKD_1_COMPAT	0x00002000	/* compatibility with MarkdownTest_1.0 */
+#define MKD_AUTOLINK	0x00004000	/* make http://foo.com link even without <>s */
+#define MKD_SAFELINK	0x00008000	/* paranoid check for link protocol */
+#define MKD_NOHEADER	0x00010000	/* don't process header blocks */
+#define MKD_TABSTOP	0x00020000	/* expand tabs to 4 spaces */
+#define MKD_NODIVQUOTE	0x00040000	/* forbid >%class% blocks */
+#define MKD_NOALPHALIST	0x00080000	/* forbid alphabetic lists */
+#define MKD_NODLIST	0x00100000	/* forbid definition lists */
+#define MKD_EXTRA_FOOTNOTE 0x00200000	/* enable markdown extra-style footnotes */
+#define MKD_NOSTYLE	0x00400000	/* don't extract <style> blocks */
+#define MKD_NODLDISCOUNT 0x00800000	/* disable discount-style definition lists */
+#define	MKD_DLEXTRA	0x01000000	/* enable extra-style definition lists */
+#define MKD_FENCEDCODE	0x02000000	/* enabled fenced code blocks */
+#define MKD_IDANCHOR	0x04000000	/* use id= anchors for TOC links */
+#define MKD_GITHUBTAGS	0x08000000	/* allow dash and underscore in element names */
+#define MKD_URLENCODEDANCHOR 0x10000000 /* urlencode non-identifier chars instead of replacing with dots */
+
+#define MKD_EMBED	MKD_NOLINKS|MKD_NOIMAGE|MKD_TAGTEXT
+
+/* special flags for mkd_in() and mkd_string()
+ */
+
+
+#endif/*_MKDIO_D*/